/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using FilterBackpropWindow3Stride2 = WindowStrideTest<Pair, 3, 2>;
TYPED_TEST_SUITE(FilterBackpropWindow3Stride2, GTestTypeTriples);
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {396., 560., 344., 552., 777.,
                                         474., 240., 326., 188.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {92.,  102., 112., 142., 152.,
                                         162., 192., 202., 212.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      740.,  792., 1042., 1120., 636., 688., 1026., 1104., 1437.,
      1554., 870., 948.,  428.,  480., 574., 652.,  324.,  376.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {156., 184., 172., 204., 188., 224.,
                                         236., 284., 252., 304., 268., 324.,
                                         316., 384., 332., 404., 348., 424.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1428., 1480., 1532., 1584., 2006., 2084., 2162., 2240., 1220.,
      1272., 1324., 1376., 1974., 2052., 2130., 2208., 2757., 2874.,
      2991., 3108., 1662., 1740., 1818., 1896., 804.,  856.,  908.,
      960.,  1070., 1148., 1226., 1304., 596.,  648.,  700.,  752.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      284., 312., 340., 368., 312., 344., 376., 408., 340., 376., 412., 448.,
      424., 472., 520., 568., 452., 504., 556., 608., 480., 536., 592., 648.,
      564., 632., 700., 768., 592., 664., 736., 808., 620., 696., 772., 848.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      764.,  792., 1081., 1120., 664., 688., 1071., 1104., 1509.,
      1554., 921., 948.,  464.,  480., 631., 652.,  364.,  376.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {174., 184., 194., 204., 214., 224.,
                                         274., 284., 294., 304., 314., 324.,
                                         374., 384., 394., 404., 414., 424.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1428., 1528., 1480., 1584., 2012., 2162., 2084., 2240., 1228.,
      1328., 1272., 1376., 1992., 2142., 2052., 2208., 2793., 3018.,
      2874., 3108., 1692., 1842., 1740., 1896., 828.,  928.,  856.,
      960.,  1112., 1262., 1148., 1304., 628.,  728.,  648.,  752.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296., 348., 312., 368., 328., 388., 344., 408., 360., 428., 376., 448.,
      456., 548., 472., 568., 488., 588., 504., 608., 520., 628., 536., 648.,
      616., 748., 632., 768., 648., 788., 664., 808., 680., 828., 696., 848.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2756., 2856., 2956., 3056., 2856., 2960., 3064., 3168., 3874.,
      4024., 4174., 4324., 4012., 4168., 4324., 4480., 2356., 2456.,
      2556., 2656., 2440., 2544., 2648., 2752., 3834., 3984., 4134.,
      4284., 3948., 4104., 4260., 4416., 5361., 5586., 5811., 6036.,
      5514., 5748., 5982., 6216., 3234., 3384., 3534., 3684., 3324.,
      3480., 3636., 3792., 1556., 1656., 1756., 1856., 1608., 1712.,
      1816., 1920., 2074., 2224., 2374., 2524., 2140., 2296., 2452.,
      2608., 1156., 1256., 1356., 1456., 1192., 1296., 1400., 1504.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,  592.,  644.,  696.,  568.,  624.,  680.,  736.,  596.,
      656.,  716.,  776.,  624.,  688.,  752.,  816.,  652.,  720.,
      788.,  856.,  680.,  752.,  824.,  896.,  820.,  912.,  1004.,
      1096., 848.,  944.,  1040., 1136., 876.,  976.,  1076., 1176.,
      904.,  1008., 1112., 1216., 932.,  1040., 1148., 1256., 960.,
      1072., 1184., 1296., 1100., 1232., 1364., 1496., 1128., 1264.,
      1400., 1536., 1156., 1296., 1436., 1576., 1184., 1328., 1472.,
      1616., 1212., 1360., 1508., 1656., 1240., 1392., 1544., 1696.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1500., 1528., 1556., 1584., 2123., 2162., 2201., 2240., 1304.,
      1328., 1352., 1376., 2109., 2142., 2175., 2208., 2973., 3018.,
      3063., 3108., 1815., 1842., 1869., 1896., 912.,  928.,  944.,
      960.,  1241., 1262., 1283., 1304., 716.,  728.,  740.,  752.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      338., 348., 358., 368., 378., 388., 398., 408., 418., 428., 438., 448.,
      538., 548., 558., 568., 578., 588., 598., 608., 618., 628., 638., 648.,
      738., 748., 758., 768., 778., 788., 798., 808., 818., 828., 838., 848.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2804., 3000., 2856., 3056., 2908., 3112., 2960., 3168., 3952.,
      4246., 4024., 4324., 4096., 4402., 4168., 4480., 2412., 2608.,
      2456., 2656., 2500., 2704., 2544., 2752., 3924., 4218., 3984.,
      4284., 4044., 4350., 4104., 4416., 5505., 5946., 5586., 6036.,
      5667., 6126., 5748., 6216., 3336., 3630., 3384., 3684., 3432.,
      3738., 3480., 3792., 1628., 1824., 1656., 1856., 1684., 1888.,
      1712., 1920., 2188., 2482., 2224., 2524., 2260., 2566., 2296.,
      2608., 1236., 1432., 1256., 1456., 1276., 1480., 1296., 1504.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      576.,  676.,  592.,  696.,  608.,  716.,  624.,  736.,  640.,
      756.,  656.,  776.,  672.,  796.,  688.,  816.,  704.,  836.,
      720.,  856.,  736.,  876.,  752.,  896.,  896.,  1076., 912.,
      1096., 928.,  1116., 944.,  1136., 960.,  1156., 976.,  1176.,
      992.,  1196., 1008., 1216., 1024., 1236., 1040., 1256., 1056.,
      1276., 1072., 1296., 1216., 1476., 1232., 1496., 1248., 1516.,
      1264., 1536., 1280., 1556., 1296., 1576., 1312., 1596., 1328.,
      1616., 1344., 1636., 1360., 1656., 1376., 1676., 1392., 1696.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5412.,  5608.,  5804.,  6000.,  5512.,  5712.,  5912.,  6112.,  5612.,
      5816.,  6020.,  6224.,  5712.,  5920.,  6128.,  6336.,  7610.,  7904.,
      8198.,  8492.,  7748.,  8048.,  8348.,  8648.,  7886.,  8192.,  8498.,
      8804.,  8024.,  8336.,  8648.,  8960.,  4628.,  4824.,  5020.,  5216.,
      4712.,  4912.,  5112.,  5312.,  4796.,  5000.,  5204.,  5408.,  4880.,
      5088.,  5296.,  5504.,  7554.,  7848.,  8142.,  8436.,  7668.,  7968.,
      8268.,  8568.,  7782.,  8088.,  8394.,  8700.,  7896.,  8208.,  8520.,
      8832.,  10569., 11010., 11451., 11892., 10722., 11172., 11622., 12072.,
      10875., 11334., 11793., 12252., 11028., 11496., 11964., 12432., 6378.,
      6672.,  6966.,  7260.,  6468.,  6768.,  7068.,  7368.,  6558.,  6864.,
      7170.,  7476.,  6648.,  6960.,  7272.,  7584.,  3060.,  3256.,  3452.,
      3648.,  3112.,  3312.,  3512.,  3712.,  3164.,  3368.,  3572.,  3776.,
      3216.,  3424.,  3632.,  3840.,  4082.,  4376.,  4670.,  4964.,  4148.,
      4448.,  4748.,  5048.,  4214.,  4520.,  4826.,  5132.,  4280.,  4592.,
      4904.,  5216.,  2276.,  2472.,  2668.,  2864.,  2312.,  2512.,  2712.,
      2912.,  2348.,  2552.,  2756.,  2960.,  2384.,  2592.,  2800.,  3008.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1052., 1152., 1252., 1352., 1080., 1184., 1288., 1392., 1108., 1216.,
      1324., 1432., 1136., 1248., 1360., 1472., 1164., 1280., 1396., 1512.,
      1192., 1312., 1432., 1552., 1220., 1344., 1468., 1592., 1248., 1376.,
      1504., 1632., 1276., 1408., 1540., 1672., 1304., 1440., 1576., 1712.,
      1332., 1472., 1612., 1752., 1360., 1504., 1648., 1792., 1612., 1792.,
      1972., 2152., 1640., 1824., 2008., 2192., 1668., 1856., 2044., 2232.,
      1696., 1888., 2080., 2272., 1724., 1920., 2116., 2312., 1752., 1952.,
      2152., 2352., 1780., 1984., 2188., 2392., 1808., 2016., 2224., 2432.,
      1836., 2048., 2260., 2472., 1864., 2080., 2296., 2512., 1892., 2112.,
      2332., 2552., 1920., 2144., 2368., 2592., 2172., 2432., 2692., 2952.,
      2200., 2464., 2728., 2992., 2228., 2496., 2764., 3032., 2256., 2528.,
      2800., 3072., 2284., 2560., 2836., 3112., 2312., 2592., 2872., 3152.,
      2340., 2624., 2908., 3192., 2368., 2656., 2944., 3232., 2396., 2688.,
      2980., 3272., 2424., 2720., 3016., 3312., 2452., 2752., 3052., 3352.,
      2480., 2784., 3088., 3392.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {647., 686., 422., 903., 948.,
                                         579., 377., 398., 230.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {106., 116., 126., 166., 176.,
                                         186., 226., 236., 246.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1204., 1294., 1276., 1372., 780., 844., 1671., 1806., 1752.,
      1896., 1062., 1158., 664.,  754., 700., 796.,  396.,  460.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {180., 212., 196., 232., 212., 252.,
                                         276., 332., 292., 352., 308., 372.,
                                         372., 452., 388., 472., 404., 492.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2318., 2408., 2498., 2588., 2456., 2552., 2648., 2744., 1496.,
      1560., 1624., 1688., 3207., 3342., 3477., 3612., 3360., 3504.,
      3648., 3792., 2028., 2124., 2220., 2316., 1238., 1328., 1418.,
      1508., 1304., 1400., 1496., 1592., 728.,  792.,  856.,  920.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      328., 360., 392., 424., 356., 392., 428., 464., 384., 424., 464., 504.,
      496., 552., 608., 664., 524., 584., 644., 704., 552., 616., 680., 744.,
      664., 744., 824., 904., 692., 776., 860., 944., 720., 808., 896., 984.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1255., 1294., 1333., 1372., 820., 844., 1761., 1806., 1851.,
      1896., 1131., 1158., 733.,  754., 775., 796.,  448.,  460.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {202., 212., 222., 232., 242., 252.,
                                         322., 332., 342., 352., 362., 372.,
                                         442., 452., 462., 472., 482., 492.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2336., 2510., 2408., 2588., 2480., 2666., 2552., 2744., 1516.,
      1640., 1560., 1688., 3261., 3522., 3342., 3612., 3423., 3702.,
      3504., 3792., 2076., 2262., 2124., 2316., 1292., 1466., 1328.,
      1508., 1364., 1550., 1400., 1592., 772.,  896.,  792.,  920.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344., 404., 360., 424., 376., 444., 392., 464., 408., 484., 424., 504.,
      536., 644., 552., 664., 568., 684., 584., 704., 600., 724., 616., 744.,
      728., 884., 744., 904., 760., 924., 776., 944., 792., 964., 808., 984.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4498., 4672., 4846., 5020., 4636., 4816., 4996., 5176., 4774.,
      4960., 5146., 5332., 4912., 5104., 5296., 5488., 2908., 3032.,
      3156., 3280., 2992., 3120., 3248., 3376., 6261., 6522., 6783.,
      7044., 6414., 6684., 6954., 7224., 6567., 6846., 7125., 7404.,
      6720., 7008., 7296., 7584., 3966., 4152., 4338., 4524., 4056.,
      4248., 4440., 4632., 2410., 2584., 2758., 2932., 2476., 2656.,
      2836., 3016., 2542., 2728., 2914., 3100., 2608., 2800., 2992.,
      3184., 1420., 1544., 1668., 1792., 1456., 1584., 1712., 1840.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      628.,  688.,  748.,  808.,  656.,  720.,  784.,  848.,  684.,
      752.,  820.,  888.,  712.,  784.,  856.,  928.,  740.,  816.,
      892.,  968.,  768.,  848.,  928.,  1008., 964.,  1072., 1180.,
      1288., 992.,  1104., 1216., 1328., 1020., 1136., 1252., 1368.,
      1048., 1168., 1288., 1408., 1076., 1200., 1324., 1448., 1104.,
      1232., 1360., 1488., 1300., 1456., 1612., 1768., 1328., 1488.,
      1648., 1808., 1356., 1520., 1684., 1848., 1384., 1552., 1720.,
      1888., 1412., 1584., 1756., 1928., 1440., 1616., 1792., 1968.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2471., 2510., 2549., 2588., 2627., 2666., 2705., 2744., 1616.,
      1640., 1664., 1688., 3477., 3522., 3567., 3612., 3657., 3702.,
      3747., 3792., 2235., 2262., 2289., 2316., 1445., 1466., 1487.,
      1508., 1529., 1550., 1571., 1592., 884.,  896.,  908.,  920.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      394., 404., 414., 424., 434., 444., 454., 464., 474., 484., 494., 504.,
      634., 644., 654., 664., 674., 684., 694., 704., 714., 724., 734., 744.,
      874., 884., 894., 904., 914., 924., 934., 944., 954., 964., 974., 984.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4600., 4942., 4672., 5020., 4744., 5098., 4816., 5176., 4888.,
      5254., 4960., 5332., 5032., 5410., 5104., 5488., 2988., 3232.,
      3032., 3280., 3076., 3328., 3120., 3376., 6441., 6954., 6522.,
      7044., 6603., 7134., 6684., 7224., 6765., 7314., 6846., 7404.,
      6927., 7494., 7008., 7584., 4104., 4470., 4152., 4524., 4200.,
      4578., 4248., 4632., 2548., 2890., 2584., 2932., 2620., 2974.,
      2656., 3016., 2692., 3058., 2728., 3100., 2764., 3142., 2800.,
      3184., 1524., 1768., 1544., 1792., 1564., 1816., 1584., 1840.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      672.,  788.,  688.,  808.,  704.,  828.,  720.,  848.,  736.,
      868.,  752.,  888.,  768.,  908.,  784.,  928.,  800.,  948.,
      816.,  968.,  832.,  988.,  848.,  1008., 1056., 1268., 1072.,
      1288., 1088., 1308., 1104., 1328., 1120., 1348., 1136., 1368.,
      1152., 1388., 1168., 1408., 1184., 1428., 1200., 1448., 1216.,
      1468., 1232., 1488., 1440., 1748., 1456., 1768., 1472., 1788.,
      1488., 1808., 1504., 1828., 1520., 1848., 1536., 1868., 1552.,
      1888., 1568., 1908., 1584., 1928., 1600., 1948., 1616., 1968.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8858.,  9200.,  9542.,  9884.,  8996.,  9344.,  9692.,  10040., 9134.,
      9488.,  9842.,  10196., 9272.,  9632.,  9992.,  10352., 9410.,  9776.,
      10142., 10508., 9548.,  9920.,  10292., 10664., 9686.,  10064., 10442.,
      10820., 9824.,  10208., 10592., 10976., 5732.,  5976.,  6220.,  6464.,
      5816.,  6064.,  6312.,  6560.,  5900.,  6152.,  6404.,  6656.,  5984.,
      6240.,  6496.,  6752.,  12369., 12882., 13395., 13908., 12522., 13044.,
      13566., 14088., 12675., 13206., 13737., 14268., 12828., 13368., 13908.,
      14448., 12981., 13530., 14079., 14628., 13134., 13692., 14250., 14808.,
      13287., 13854., 14421., 14988., 13440., 14016., 14592., 15168., 7842.,
      8208.,  8574.,  8940.,  7932.,  8304.,  8676.,  9048.,  8022.,  8400.,
      8778.,  9156.,  8112.,  8496.,  8880.,  9264.,  4754.,  5096.,  5438.,
      5780.,  4820.,  5168.,  5516.,  5864.,  4886.,  5240.,  5594.,  5948.,
      4952.,  5312.,  5672.,  6032.,  5018.,  5384.,  5750.,  6116.,  5084.,
      5456.,  5828.,  6200.,  5150.,  5528.,  5906.,  6284.,  5216.,  5600.,
      5984.,  6368.,  2804.,  3048.,  3292.,  3536.,  2840.,  3088.,  3336.,
      3584.,  2876.,  3128.,  3380.,  3632.,  2912.,  3168.,  3424.,  3680.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1228., 1344., 1460., 1576., 1256., 1376., 1496., 1616., 1284., 1408.,
      1532., 1656., 1312., 1440., 1568., 1696., 1340., 1472., 1604., 1736.,
      1368., 1504., 1640., 1776., 1396., 1536., 1676., 1816., 1424., 1568.,
      1712., 1856., 1452., 1600., 1748., 1896., 1480., 1632., 1784., 1936.,
      1508., 1664., 1820., 1976., 1536., 1696., 1856., 2016., 1900., 2112.,
      2324., 2536., 1928., 2144., 2360., 2576., 1956., 2176., 2396., 2616.,
      1984., 2208., 2432., 2656., 2012., 2240., 2468., 2696., 2040., 2272.,
      2504., 2736., 2068., 2304., 2540., 2776., 2096., 2336., 2576., 2816.,
      2124., 2368., 2612., 2856., 2152., 2400., 2648., 2896., 2180., 2432.,
      2684., 2936., 2208., 2464., 2720., 2976., 2572., 2880., 3188., 3496.,
      2600., 2912., 3224., 3536., 2628., 2944., 3260., 3576., 2656., 2976.,
      3296., 3616., 2684., 3008., 3332., 3656., 2712., 3040., 3368., 3696.,
      2740., 3072., 3404., 3736., 2768., 3104., 3440., 3776., 2796., 3136.,
      3476., 3816., 2824., 3168., 3512., 3856., 2852., 3200., 3548., 3896.,
      2880., 3232., 3584., 3936.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1508., 1576., 1112., 2102., 2180.,
                                         1530., 868.,  904.,  608.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {311., 332., 353., 479., 500.,
                                         521., 647., 668., 689.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2856., 3016., 2984., 3152., 2098., 2224., 3964., 4204., 4108.,
      4360., 2871., 3060., 1576., 1736., 1640., 1808., 1090., 1216.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      556.,  622., 592.,  664.,  628.,  706.,  844.,  958.,  880.,
      1000., 916., 1042., 1132., 1294., 1168., 1336., 1204., 1378.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5552., 5712., 5872., 6032., 5800., 5968., 6136., 6304., 4070.,
      4196., 4322., 4448., 7688., 7928., 8168., 8408., 7964., 8216.,
      8468., 8720., 5553., 5742., 5931., 6120., 2992., 3152., 3312.,
      3472., 3112., 3280., 3448., 3616., 2054., 2180., 2306., 2432.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1046., 1112., 1178., 1244., 1112., 1184., 1256., 1328., 1178.,
      1256., 1334., 1412., 1574., 1688., 1802., 1916., 1640., 1760.,
      1880., 2000., 1706., 1832., 1958., 2084., 2102., 2264., 2426.,
      2588., 2168., 2336., 2504., 2672., 2234., 2408., 2582., 2756.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2948., 3016., 3084., 3152., 2176., 2224., 4126., 4204., 4282.,
      4360., 3006., 3060., 1700., 1736., 1772., 1808., 1192., 1216.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      601.,  622.,  643.,  664.,  685.,  706.,  937.,  958.,  979.,
      1000., 1021., 1042., 1273., 1294., 1315., 1336., 1357., 1378.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5584., 5896., 5712., 6032., 5840., 6168., 5968., 6304., 4106.,
      4352., 4196., 4448., 7784., 8252., 7928., 8408., 8072., 8564.,
      8216., 8720., 5643., 6012., 5742., 6120., 3088., 3400., 3152.,
      3472., 3216., 3544., 3280., 3616., 2138., 2384., 2180., 2432.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1076., 1202., 1112., 1244., 1148., 1286., 1184., 1328., 1220.,
      1370., 1256., 1412., 1652., 1874., 1688., 1916., 1724., 1958.,
      1760., 2000., 1796., 2042., 1832., 2084., 2228., 2546., 2264.,
      2588., 2300., 2630., 2336., 2672., 2372., 2714., 2408., 2756.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10856., 11168., 11480., 11792., 11104., 11424., 11744., 12064., 11352.,
      11680., 12008., 12336., 11600., 11936., 12272., 12608., 7966.,  8212.,
      8458.,  8704.,  8140.,  8392.,  8644.,  8896.,  15100., 15568., 16036.,
      16504., 15376., 15856., 16336., 16816., 15652., 16144., 16636., 17128.,
      15928., 16432., 16936., 17440., 10917., 11286., 11655., 12024., 11106.,
      11484., 11862., 12240., 5864.,  6176.,  6488.,  6800.,  5984.,  6304.,
      6624.,  6944.,  6104.,  6432.,  6760.,  7088.,  6224.,  6560.,  6896.,
      7232.,  4030.,  4276.,  4522.,  4768.,  4108.,  4360.,  4612.,  4864.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2026., 2152., 2278., 2404., 2092., 2224., 2356., 2488., 2158.,
      2296., 2434., 2572., 2224., 2368., 2512., 2656., 2290., 2440.,
      2590., 2740., 2356., 2512., 2668., 2824., 3082., 3304., 3526.,
      3748., 3148., 3376., 3604., 3832., 3214., 3448., 3682., 3916.,
      3280., 3520., 3760., 4000., 3346., 3592., 3838., 4084., 3412.,
      3664., 3916., 4168., 4138., 4456., 4774., 5092., 4204., 4528.,
      4852., 5176., 4270., 4600., 4930., 5260., 4336., 4672., 5008.,
      5344., 4402., 4744., 5086., 5428., 4468., 4816., 5164., 5512.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5828., 5896., 5964., 6032., 6100., 6168., 6236., 6304., 4304.,
      4352., 4400., 4448., 8174., 8252., 8330., 8408., 8486., 8564.,
      8642., 8720., 5958., 6012., 6066., 6120., 3364., 3400., 3436.,
      3472., 3508., 3544., 3580., 3616., 2360., 2384., 2408., 2432.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1181., 1202., 1223., 1244., 1265., 1286., 1307., 1328., 1349.,
      1370., 1391., 1412., 1853., 1874., 1895., 1916., 1937., 1958.,
      1979., 2000., 2021., 2042., 2063., 2084., 2525., 2546., 2567.,
      2588., 2609., 2630., 2651., 2672., 2693., 2714., 2735., 2756.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11040., 11656., 11168., 11792., 11296., 11928., 11424., 12064., 11552.,
      12200., 11680., 12336., 11808., 12472., 11936., 12608., 8122.,  8608.,
      8212.,  8704.,  8302.,  8800.,  8392.,  8896.,  15424., 16348., 15568.,
      16504., 15712., 16660., 15856., 16816., 16000., 16972., 16144., 17128.,
      16288., 17284., 16432., 17440., 11187., 11916., 11286., 12024., 11385.,
      12132., 11484., 12240., 6112.,  6728.,  6176.,  6800.,  6240.,  6872.,
      6304.,  6944.,  6368.,  7016.,  6432.,  7088.,  6496.,  7160.,  6560.,
      7232.,  4234.,  4720.,  4276.,  4768.,  4318.,  4816.,  4360.,  4864.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2116., 2362., 2152., 2404., 2188., 2446., 2224., 2488., 2260.,
      2530., 2296., 2572., 2332., 2614., 2368., 2656., 2404., 2698.,
      2440., 2740., 2476., 2782., 2512., 2824., 3268., 3706., 3304.,
      3748., 3340., 3790., 3376., 3832., 3412., 3874., 3448., 3916.,
      3484., 3958., 3520., 4000., 3556., 4042., 3592., 4084., 3628.,
      4126., 3664., 4168., 4420., 5050., 4456., 5092., 4492., 5134.,
      4528., 5176., 4564., 5218., 4600., 5260., 4636., 5302., 4672.,
      5344., 4708., 5386., 4744., 5428., 4780., 5470., 4816., 5512.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21464., 22080., 22696., 23312., 21712., 22336., 22960., 23584., 21960.,
      22592., 23224., 23856., 22208., 22848., 23488., 24128., 22456., 23104.,
      23752., 24400., 22704., 23360., 24016., 24672., 22952., 23616., 24280.,
      24944., 23200., 23872., 24544., 25216., 15758., 16244., 16730., 17216.,
      15932., 16424., 16916., 17408., 16106., 16604., 17102., 17600., 16280.,
      16784., 17288., 17792., 29924., 30848., 31772., 32696., 30200., 31136.,
      32072., 33008., 30476., 31424., 32372., 33320., 30752., 31712., 32672.,
      33632., 31028., 32000., 32972., 33944., 31304., 32288., 33272., 34256.,
      31580., 32576., 33572., 34568., 31856., 32864., 33872., 34880., 21645.,
      22374., 23103., 23832., 21834., 22572., 23310., 24048., 22023., 22770.,
      23517., 24264., 22212., 22968., 23724., 24480., 11608., 12224., 12840.,
      13456., 11728., 12352., 12976., 13600., 11848., 12480., 13112., 13744.,
      11968., 12608., 13248., 13888., 12088., 12736., 13384., 14032., 12208.,
      12864., 13520., 14176., 12328., 12992., 13656., 14320., 12448., 13120.,
      13792., 14464., 7982.,  8468.,  8954.,  9440.,  8060.,  8552.,  9044.,
      9536.,  8138.,  8636.,  9134.,  9632.,  8216.,  8720.,  9224.,  9728.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3986.,  4232.,  4478.,  4724.,  4052.,  4304.,  4556.,  4808.,  4118.,
      4376.,  4634.,  4892.,  4184.,  4448.,  4712.,  4976.,  4250.,  4520.,
      4790.,  5060.,  4316.,  4592.,  4868.,  5144.,  4382.,  4664.,  4946.,
      5228.,  4448.,  4736.,  5024.,  5312.,  4514.,  4808.,  5102.,  5396.,
      4580.,  4880.,  5180.,  5480.,  4646.,  4952.,  5258.,  5564.,  4712.,
      5024.,  5336.,  5648.,  6098.,  6536.,  6974.,  7412.,  6164.,  6608.,
      7052.,  7496.,  6230.,  6680.,  7130.,  7580.,  6296.,  6752.,  7208.,
      7664.,  6362.,  6824.,  7286.,  7748.,  6428.,  6896.,  7364.,  7832.,
      6494.,  6968.,  7442.,  7916.,  6560.,  7040.,  7520.,  8000.,  6626.,
      7112.,  7598.,  8084.,  6692.,  7184.,  7676.,  8168.,  6758.,  7256.,
      7754.,  8252.,  6824.,  7328.,  7832.,  8336.,  8210.,  8840.,  9470.,
      10100., 8276.,  8912.,  9548.,  10184., 8342.,  8984.,  9626.,  10268.,
      8408.,  9056.,  9704.,  10352., 8474.,  9128.,  9782.,  10436., 8540.,
      9200.,  9860.,  10520., 8606.,  9272.,  9938.,  10604., 8672.,  9344.,
      10016., 10688., 8738.,  9416.,  10094., 10772., 8804.,  9488.,  10172.,
      10856., 8870.,  9560.,  10250., 10940., 8936.,  9632.,  10328., 11024.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {552., 777., 474., 717., 1002.,
                                         609., 320., 431., 248.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {92.,  102., 112., 142., 152.,
                                         162., 192., 202., 212.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1026., 1104., 1437., 1554., 870., 948., 1326., 1434., 1842.,
      2004., 1110., 1218., 568.,  640., 754., 862.,  424.,  496.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {156., 184., 172., 204., 188., 224.,
                                         236., 284., 252., 304., 268., 324.,
                                         316., 384., 332., 404., 348., 424.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1974., 2052., 2130., 2208., 2757., 2874., 2991., 3108., 1662.,
      1740., 1818., 1896., 2544., 2652., 2760., 2868., 3522., 3684.,
      3846., 4008., 2112., 2220., 2328., 2436., 1064., 1136., 1208.,
      1280., 1400., 1508., 1616., 1724., 776.,  848.,  920.,  992.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      284., 312., 340., 368., 312., 344., 376., 408., 340., 376., 412., 448.,
      424., 472., 520., 568., 452., 504., 556., 608., 480., 536., 592., 648.,
      564., 632., 700., 768., 592., 664., 736., 808., 620., 696., 772., 848.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1071., 1104., 1509., 1554., 921., 948., 1401., 1434., 1959.,
      2004., 1191., 1218., 624.,  640., 841., 862.,  484.,  496.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {174., 184., 194., 204., 214., 224.,
                                         274., 284., 294., 304., 314., 324.,
                                         374., 384., 394., 404., 414., 424.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1992., 2142., 2052., 2208., 2793., 3018., 2874., 3108., 1692.,
      1842., 1740., 1896., 2592., 2802., 2652., 2868., 3603., 3918.,
      3684., 4008., 2172., 2382., 2220., 2436., 1108., 1248., 1136.,
      1280., 1472., 1682., 1508., 1724., 828.,  968.,  848.,  992.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296., 348., 312., 368., 328., 388., 344., 408., 360., 428., 376., 448.,
      456., 548., 472., 568., 488., 588., 504., 608., 520., 628., 536., 648.,
      616., 748., 632., 768., 648., 788., 664., 808., 680., 828., 696., 848.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3834., 3984., 4134., 4284., 3948., 4104., 4260., 4416., 5361.,
      5586., 5811., 6036., 5514., 5748., 5982., 6216., 3234., 3384.,
      3534., 3684., 3324., 3480., 3636., 3792., 4974., 5184., 5394.,
      5604., 5088., 5304., 5520., 5736., 6891., 7206., 7521., 7836.,
      7044., 7368., 7692., 8016., 4134., 4344., 4554., 4764., 4224.,
      4440., 4656., 4872., 2076., 2216., 2356., 2496., 2128., 2272.,
      2416., 2560., 2734., 2944., 3154., 3364., 2800., 3016., 3232.,
      3448., 1516., 1656., 1796., 1936., 1552., 1696., 1840., 1984.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,  592.,  644.,  696.,  568.,  624.,  680.,  736.,  596.,
      656.,  716.,  776.,  624.,  688.,  752.,  816.,  652.,  720.,
      788.,  856.,  680.,  752.,  824.,  896.,  820.,  912.,  1004.,
      1096., 848.,  944.,  1040., 1136., 876.,  976.,  1076., 1176.,
      904.,  1008., 1112., 1216., 932.,  1040., 1148., 1256., 960.,
      1072., 1184., 1296., 1100., 1232., 1364., 1496., 1128., 1264.,
      1400., 1536., 1156., 1296., 1436., 1576., 1184., 1328., 1472.,
      1616., 1212., 1360., 1508., 1656., 1240., 1392., 1544., 1696.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2109., 2142., 2175., 2208., 2973., 3018., 3063., 3108., 1815.,
      1842., 1869., 1896., 2769., 2802., 2835., 2868., 3873., 3918.,
      3963., 4008., 2355., 2382., 2409., 2436., 1232., 1248., 1264.,
      1280., 1661., 1682., 1703., 1724., 956.,  968.,  980.,  992.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      338., 348., 358., 368., 378., 388., 398., 408., 418., 428., 438., 448.,
      538., 548., 558., 568., 578., 588., 598., 608., 618., 628., 638., 648.,
      738., 748., 758., 768., 778., 788., 798., 808., 818., 828., 838., 848.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3924., 4218., 3984., 4284., 4044., 4350., 4104., 4416., 5505.,
      5946., 5586., 6036., 5667., 6126., 5748., 6216., 3336., 3630.,
      3384., 3684., 3432., 3738., 3480., 3792., 5124., 5538., 5184.,
      5604., 5244., 5670., 5304., 5736., 7125., 7746., 7206., 7836.,
      7287., 7926., 7368., 8016., 4296., 4710., 4344., 4764., 4392.,
      4818., 4440., 4872., 2188., 2464., 2216., 2496., 2244., 2528.,
      2272., 2560., 2908., 3322., 2944., 3364., 2980., 3406., 3016.,
      3448., 1636., 1912., 1656., 1936., 1676., 1960., 1696., 1984.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      576.,  676.,  592.,  696.,  608.,  716.,  624.,  736.,  640.,
      756.,  656.,  776.,  672.,  796.,  688.,  816.,  704.,  836.,
      720.,  856.,  736.,  876.,  752.,  896.,  896.,  1076., 912.,
      1096., 928.,  1116., 944.,  1136., 960.,  1156., 976.,  1176.,
      992.,  1196., 1008., 1216., 1024., 1236., 1040., 1256., 1056.,
      1276., 1072., 1296., 1216., 1476., 1232., 1496., 1248., 1516.,
      1264., 1536., 1280., 1556., 1296., 1576., 1312., 1596., 1328.,
      1616., 1344., 1636., 1360., 1656., 1376., 1676., 1392., 1696.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7554.,  7848.,  8142.,  8436.,  7668.,  7968.,  8268.,  8568.,  7782.,
      8088.,  8394.,  8700.,  7896.,  8208.,  8520.,  8832.,  10569., 11010.,
      11451., 11892., 10722., 11172., 11622., 12072., 10875., 11334., 11793.,
      12252., 11028., 11496., 11964., 12432., 6378.,  6672.,  6966.,  7260.,
      6468.,  6768.,  7068.,  7368.,  6558.,  6864.,  7170.,  7476.,  6648.,
      6960.,  7272.,  7584.,  9834.,  10248., 10662., 11076., 9948.,  10368.,
      10788., 11208., 10062., 10488., 10914., 11340., 10176., 10608., 11040.,
      11472., 13629., 14250., 14871., 15492., 13782., 14412., 15042., 15672.,
      13935., 14574., 15213., 15852., 14088., 14736., 15384., 16032., 8178.,
      8592.,  9006.,  9420.,  8268.,  8688.,  9108.,  9528.,  8358.,  8784.,
      9210.,  9636.,  8448.,  8880.,  9312.,  9744.,  4100.,  4376.,  4652.,
      4928.,  4152.,  4432.,  4712.,  4992.,  4204.,  4488.,  4772.,  5056.,
      4256.,  4544.,  4832.,  5120.,  5402.,  5816.,  6230.,  6644.,  5468.,
      5888.,  6308.,  6728.,  5534.,  5960.,  6386.,  6812.,  5600.,  6032.,
      6464.,  6896.,  2996.,  3272.,  3548.,  3824.,  3032.,  3312.,  3592.,
      3872.,  3068.,  3352.,  3636.,  3920.,  3104.,  3392.,  3680.,  3968.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1052., 1152., 1252., 1352., 1080., 1184., 1288., 1392., 1108., 1216.,
      1324., 1432., 1136., 1248., 1360., 1472., 1164., 1280., 1396., 1512.,
      1192., 1312., 1432., 1552., 1220., 1344., 1468., 1592., 1248., 1376.,
      1504., 1632., 1276., 1408., 1540., 1672., 1304., 1440., 1576., 1712.,
      1332., 1472., 1612., 1752., 1360., 1504., 1648., 1792., 1612., 1792.,
      1972., 2152., 1640., 1824., 2008., 2192., 1668., 1856., 2044., 2232.,
      1696., 1888., 2080., 2272., 1724., 1920., 2116., 2312., 1752., 1952.,
      2152., 2352., 1780., 1984., 2188., 2392., 1808., 2016., 2224., 2432.,
      1836., 2048., 2260., 2472., 1864., 2080., 2296., 2512., 1892., 2112.,
      2332., 2552., 1920., 2144., 2368., 2592., 2172., 2432., 2692., 2952.,
      2200., 2464., 2728., 2992., 2228., 2496., 2764., 3032., 2256., 2528.,
      2800., 3072., 2284., 2560., 2836., 3112., 2312., 2592., 2872., 3152.,
      2340., 2624., 2908., 3192., 2368., 2656., 2944., 3232., 2396., 2688.,
      2980., 3272., 2424., 2720., 3016., 3312., 2452., 2752., 3052., 3352.,
      2480., 2784., 3088., 3392.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {903., 948., 579., 1173., 1218.,
                                         741., 503., 524., 302.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {106., 116., 126., 166., 176.,
                                         186., 226., 236., 246.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671., 1806., 1752., 1896., 1062., 1158., 2157., 2346., 2238.,
      2436., 1350., 1482., 880.,  1006., 916.,  1048., 516.,  604.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {180., 212., 196., 232., 212., 252.,
                                         276., 332., 292., 352., 308., 372.,
                                         372., 452., 388., 472., 404., 492.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207., 3342., 3477., 3612., 3360., 3504., 3648., 3792., 2028.,
      2124., 2220., 2316., 4125., 4314., 4503., 4692., 4278., 4476.,
      4674., 4872., 2568., 2700., 2832., 2964., 1634., 1760., 1886.,
      2012., 1700., 1832., 1964., 2096., 944.,  1032., 1120., 1208.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      328., 360., 392., 424., 356., 392., 428., 464., 384., 424., 464., 504.,
      496., 552., 608., 664., 524., 584., 644., 704., 552., 616., 680., 744.,
      664., 744., 824., 904., 692., 776., 860., 944., 720., 808., 896., 984.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1761., 1806., 1851., 1896., 1131., 1158., 2301., 2346., 2391.,
      2436., 1455., 1482., 985.,  1006., 1027., 1048., 592.,  604.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {202., 212., 222., 232., 242., 252.,
                                         322., 332., 342., 352., 362., 372.,
                                         442., 452., 462., 472., 482., 492.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3261., 3522., 3342., 3612., 3423., 3702., 3504., 3792., 2076.,
      2262., 2124., 2316., 4233., 4602., 4314., 4692., 4395., 4782.,
      4476., 4872., 2652., 2910., 2700., 2964., 1724., 1970., 1760.,
      2012., 1796., 2054., 1832., 2096., 1012., 1184., 1032., 1208.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344., 404., 360., 424., 376., 444., 392., 464., 408., 484., 424., 504.,
      536., 644., 552., 664., 568., 684., 584., 704., 600., 724., 616., 744.,
      728., 884., 744., 904., 760., 924., 776., 944., 792., 964., 808., 984.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261., 6522., 6783., 7044., 6414., 6684., 6954., 7224., 6567.,
      6846., 7125., 7404., 6720., 7008., 7296., 7584., 3966., 4152.,
      4338., 4524., 4056., 4248., 4440., 4632., 8097., 8466., 8835.,
      9204., 8250., 8628., 9006., 9384., 8403., 8790., 9177., 9564.,
      8556., 8952., 9348., 9744., 5046., 5304., 5562., 5820., 5136.,
      5400., 5664., 5928., 3202., 3448., 3694., 3940., 3268., 3520.,
      3772., 4024., 3334., 3592., 3850., 4108., 3400., 3664., 3928.,
      4192., 1852., 2024., 2196., 2368., 1888., 2064., 2240., 2416.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      628.,  688.,  748.,  808.,  656.,  720.,  784.,  848.,  684.,
      752.,  820.,  888.,  712.,  784.,  856.,  928.,  740.,  816.,
      892.,  968.,  768.,  848.,  928.,  1008., 964.,  1072., 1180.,
      1288., 992.,  1104., 1216., 1328., 1020., 1136., 1252., 1368.,
      1048., 1168., 1288., 1408., 1076., 1200., 1324., 1448., 1104.,
      1232., 1360., 1488., 1300., 1456., 1612., 1768., 1328., 1488.,
      1648., 1808., 1356., 1520., 1684., 1848., 1384., 1552., 1720.,
      1888., 1412., 1584., 1756., 1928., 1440., 1616., 1792., 1968.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3477., 3522., 3567., 3612., 3657., 3702., 3747., 3792., 2235.,
      2262., 2289., 2316., 4557., 4602., 4647., 4692., 4737., 4782.,
      4827., 4872., 2883., 2910., 2937., 2964., 1949., 1970., 1991.,
      2012., 2033., 2054., 2075., 2096., 1172., 1184., 1196., 1208.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      394., 404., 414., 424., 434., 444., 454., 464., 474., 484., 494., 504.,
      634., 644., 654., 664., 674., 684., 694., 704., 714., 724., 734., 744.,
      874., 884., 894., 904., 914., 924., 934., 944., 954., 964., 974., 984.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6441., 6954., 6522., 7044., 6603., 7134., 6684., 7224., 6765.,
      7314., 6846., 7404., 6927., 7494., 7008., 7584., 4104., 4470.,
      4152., 4524., 4200., 4578., 4248., 4632., 8385., 9114., 8466.,
      9204., 8547., 9294., 8628., 9384., 8709., 9474., 8790., 9564.,
      8871., 9654., 8952., 9744., 5256., 5766., 5304., 5820., 5352.,
      5874., 5400., 5928., 3412., 3898., 3448., 3940., 3484., 3982.,
      3520., 4024., 3556., 4066., 3592., 4108., 3628., 4150., 3664.,
      4192., 2004., 2344., 2024., 2368., 2044., 2392., 2064., 2416.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      672.,  788.,  688.,  808.,  704.,  828.,  720.,  848.,  736.,
      868.,  752.,  888.,  768.,  908.,  784.,  928.,  800.,  948.,
      816.,  968.,  832.,  988.,  848.,  1008., 1056., 1268., 1072.,
      1288., 1088., 1308., 1104., 1328., 1120., 1348., 1136., 1368.,
      1152., 1388., 1168., 1408., 1184., 1428., 1200., 1448., 1216.,
      1468., 1232., 1488., 1440., 1748., 1456., 1768., 1472., 1788.,
      1488., 1808., 1504., 1828., 1520., 1848., 1536., 1868., 1552.,
      1888., 1568., 1908., 1584., 1928., 1600., 1948., 1616., 1968.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12369., 12882., 13395., 13908., 12522., 13044., 13566., 14088., 12675.,
      13206., 13737., 14268., 12828., 13368., 13908., 14448., 12981., 13530.,
      14079., 14628., 13134., 13692., 14250., 14808., 13287., 13854., 14421.,
      14988., 13440., 14016., 14592., 15168., 7842.,  8208.,  8574.,  8940.,
      7932.,  8304.,  8676.,  9048.,  8022.,  8400.,  8778.,  9156.,  8112.,
      8496.,  8880.,  9264.,  16041., 16770., 17499., 18228., 16194., 16932.,
      17670., 18408., 16347., 17094., 17841., 18588., 16500., 17256., 18012.,
      18768., 16653., 17418., 18183., 18948., 16806., 17580., 18354., 19128.,
      16959., 17742., 18525., 19308., 17112., 17904., 18696., 19488., 10002.,
      10512., 11022., 11532., 10092., 10608., 11124., 11640., 10182., 10704.,
      11226., 11748., 10272., 10800., 11328., 11856., 6338.,  6824.,  7310.,
      7796.,  6404.,  6896.,  7388.,  7880.,  6470.,  6968.,  7466.,  7964.,
      6536.,  7040.,  7544.,  8048.,  6602.,  7112.,  7622.,  8132.,  6668.,
      7184.,  7700.,  8216.,  6734.,  7256.,  7778.,  8300.,  6800.,  7328.,
      7856.,  8384.,  3668.,  4008.,  4348.,  4688.,  3704.,  4048.,  4392.,
      4736.,  3740.,  4088.,  4436.,  4784.,  3776.,  4128.,  4480.,  4832.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1228., 1344., 1460., 1576., 1256., 1376., 1496., 1616., 1284., 1408.,
      1532., 1656., 1312., 1440., 1568., 1696., 1340., 1472., 1604., 1736.,
      1368., 1504., 1640., 1776., 1396., 1536., 1676., 1816., 1424., 1568.,
      1712., 1856., 1452., 1600., 1748., 1896., 1480., 1632., 1784., 1936.,
      1508., 1664., 1820., 1976., 1536., 1696., 1856., 2016., 1900., 2112.,
      2324., 2536., 1928., 2144., 2360., 2576., 1956., 2176., 2396., 2616.,
      1984., 2208., 2432., 2656., 2012., 2240., 2468., 2696., 2040., 2272.,
      2504., 2736., 2068., 2304., 2540., 2776., 2096., 2336., 2576., 2816.,
      2124., 2368., 2612., 2856., 2152., 2400., 2648., 2896., 2180., 2432.,
      2684., 2936., 2208., 2464., 2720., 2976., 2572., 2880., 3188., 3496.,
      2600., 2912., 3224., 3536., 2628., 2944., 3260., 3576., 2656., 2976.,
      3296., 3616., 2684., 3008., 3332., 3656., 2712., 3040., 3368., 3696.,
      2740., 3072., 3404., 3736., 2768., 3104., 3440., 3776., 2796., 3136.,
      3476., 3816., 2824., 3168., 3512., 3856., 2852., 3200., 3548., 3896.,
      2880., 3232., 3584., 3936.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2102., 2180., 1530., 2726., 2804.,
                                         1962., 1156., 1192., 800.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {311., 332., 353., 479., 500.,
                                         521., 647., 668., 689.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3964., 4204., 4108., 4360., 2871., 3060., 5116., 5452., 5260.,
      5608., 3663., 3924., 2088., 2312., 2152., 2384., 1426., 1600.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      556.,  622., 592.,  664.,  628.,  706.,  844.,  958.,  880.,
      1000., 916., 1042., 1132., 1294., 1168., 1336., 1204., 1378.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7688.,  7928.,  8168., 8408., 7964.,  8216.,  8468.,  8720.,  5553.,
      5742.,  5931.,  6120., 9896., 10232., 10568., 10904., 10172., 10520.,
      10868., 11216., 7065., 7326., 7587.,  7848.,  3952.,  4176.,  4400.,
      4624.,  4072.,  4304., 4536., 4768.,  2678.,  2852.,  3026.,  3200.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1046., 1112., 1178., 1244., 1112., 1184., 1256., 1328., 1178.,
      1256., 1334., 1412., 1574., 1688., 1802., 1916., 1640., 1760.,
      1880., 2000., 1706., 1832., 1958., 2084., 2102., 2264., 2426.,
      2588., 2168., 2336., 2504., 2672., 2234., 2408., 2582., 2756.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4126., 4204., 4282., 4360., 3006., 3060., 5374., 5452., 5530.,
      5608., 3870., 3924., 2276., 2312., 2348., 2384., 1576., 1600.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      601.,  622.,  643.,  664.,  685.,  706.,  937.,  958.,  979.,
      1000., 1021., 1042., 1273., 1294., 1315., 1336., 1357., 1378.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7784.,  8252.,  7928., 8408.,  8072.,  8564.,  8216.,  8720.,  5643.,
      6012.,  5742.,  6120., 10088., 10748., 10232., 10904., 10376., 11060.,
      10520., 11216., 7227., 7740.,  7326.,  7848.,  4112.,  4552.,  4176.,
      4624.,  4240.,  4696., 4304.,  4768.,  2810.,  3152.,  2852.,  3200.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1076., 1202., 1112., 1244., 1148., 1286., 1184., 1328., 1220.,
      1370., 1256., 1412., 1652., 1874., 1688., 1916., 1724., 1958.,
      1760., 2000., 1796., 2042., 1832., 2084., 2228., 2546., 2264.,
      2588., 2300., 2630., 2336., 2672., 2372., 2714., 2408., 2756.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15100., 15568., 16036., 16504., 15376., 15856., 16336., 16816., 15652.,
      16144., 16636., 17128., 15928., 16432., 16936., 17440., 10917., 11286.,
      11655., 12024., 11106., 11484., 11862., 12240., 19516., 20176., 20836.,
      21496., 19792., 20464., 21136., 21808., 20068., 20752., 21436., 22120.,
      20344., 21040., 21736., 22432., 13941., 14454., 14967., 15480., 14130.,
      14652., 15174., 15696., 7784.,  8224.,  8664.,  9104.,  7904.,  8352.,
      8800.,  9248.,  8024.,  8480.,  8936.,  9392.,  8144.,  8608.,  9072.,
      9536.,  5278.,  5620.,  5962.,  6304.,  5356.,  5704.,  6052.,  6400.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2026., 2152., 2278., 2404., 2092., 2224., 2356., 2488., 2158.,
      2296., 2434., 2572., 2224., 2368., 2512., 2656., 2290., 2440.,
      2590., 2740., 2356., 2512., 2668., 2824., 3082., 3304., 3526.,
      3748., 3148., 3376., 3604., 3832., 3214., 3448., 3682., 3916.,
      3280., 3520., 3760., 4000., 3346., 3592., 3838., 4084., 3412.,
      3664., 3916., 4168., 4138., 4456., 4774., 5092., 4204., 4528.,
      4852., 5176., 4270., 4600., 4930., 5260., 4336., 4672., 5008.,
      5344., 4402., 4744., 5086., 5428., 4468., 4816., 5164., 5512.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8174.,  8252.,  8330., 8408.,  8486.,  8564.,  8642.,  8720.,  5958.,
      6012.,  6066.,  6120., 10670., 10748., 10826., 10904., 10982., 11060.,
      11138., 11216., 7686., 7740.,  7794.,  7848.,  4516.,  4552.,  4588.,
      4624.,  4660.,  4696., 4732.,  4768.,  3128.,  3152.,  3176.,  3200.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1181., 1202., 1223., 1244., 1265., 1286., 1307., 1328., 1349.,
      1370., 1391., 1412., 1853., 1874., 1895., 1916., 1937., 1958.,
      1979., 2000., 2021., 2042., 2063., 2084., 2525., 2546., 2567.,
      2588., 2609., 2630., 2651., 2672., 2693., 2714., 2735., 2756.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15424., 16348., 15568., 16504., 15712., 16660., 15856., 16816., 16000.,
      16972., 16144., 17128., 16288., 17284., 16432., 17440., 11187., 11916.,
      11286., 12024., 11385., 12132., 11484., 12240., 20032., 21340., 20176.,
      21496., 20320., 21652., 20464., 21808., 20608., 21964., 20752., 22120.,
      20896., 22276., 21040., 22432., 14355., 15372., 14454., 15480., 14553.,
      15588., 14652., 15696., 8160.,  9032.,  8224.,  9104.,  8288.,  9176.,
      8352.,  9248.,  8416.,  9320.,  8480.,  9392.,  8544.,  9464.,  8608.,
      9536.,  5578.,  6256.,  5620.,  6304.,  5662.,  6352.,  5704.,  6400.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2116., 2362., 2152., 2404., 2188., 2446., 2224., 2488., 2260.,
      2530., 2296., 2572., 2332., 2614., 2368., 2656., 2404., 2698.,
      2440., 2740., 2476., 2782., 2512., 2824., 3268., 3706., 3304.,
      3748., 3340., 3790., 3376., 3832., 3412., 3874., 3448., 3916.,
      3484., 3958., 3520., 4000., 3556., 4042., 3592., 4084., 3628.,
      4126., 3664., 4168., 4420., 5050., 4456., 5092., 4492., 5134.,
      4528., 5176., 4564., 5218., 4600., 5260., 4636., 5302., 4672.,
      5344., 4708., 5386., 4744., 5428., 4780., 5470., 4816., 5512.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29924., 30848., 31772., 32696., 30200., 31136., 32072., 33008., 30476.,
      31424., 32372., 33320., 30752., 31712., 32672., 33632., 31028., 32000.,
      32972., 33944., 31304., 32288., 33272., 34256., 31580., 32576., 33572.,
      34568., 31856., 32864., 33872., 34880., 21645., 22374., 23103., 23832.,
      21834., 22572., 23310., 24048., 22023., 22770., 23517., 24264., 22212.,
      22968., 23724., 24480., 38756., 40064., 41372., 42680., 39032., 40352.,
      41672., 42992., 39308., 40640., 41972., 43304., 39584., 40928., 42272.,
      43616., 39860., 41216., 42572., 43928., 40136., 41504., 42872., 44240.,
      40412., 41792., 43172., 44552., 40688., 42080., 43472., 44864., 27693.,
      28710., 29727., 30744., 27882., 28908., 29934., 30960., 28071., 29106.,
      30141., 31176., 28260., 29304., 30348., 31392., 15448., 16320., 17192.,
      18064., 15568., 16448., 17328., 18208., 15688., 16576., 17464., 18352.,
      15808., 16704., 17600., 18496., 15928., 16832., 17736., 18640., 16048.,
      16960., 17872., 18784., 16168., 17088., 18008., 18928., 16288., 17216.,
      18144., 19072., 10478., 11156., 11834., 12512., 10556., 11240., 11924.,
      12608., 10634., 11324., 12014., 12704., 10712., 11408., 12104., 12800.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3986.,  4232.,  4478.,  4724.,  4052.,  4304.,  4556.,  4808.,  4118.,
      4376.,  4634.,  4892.,  4184.,  4448.,  4712.,  4976.,  4250.,  4520.,
      4790.,  5060.,  4316.,  4592.,  4868.,  5144.,  4382.,  4664.,  4946.,
      5228.,  4448.,  4736.,  5024.,  5312.,  4514.,  4808.,  5102.,  5396.,
      4580.,  4880.,  5180.,  5480.,  4646.,  4952.,  5258.,  5564.,  4712.,
      5024.,  5336.,  5648.,  6098.,  6536.,  6974.,  7412.,  6164.,  6608.,
      7052.,  7496.,  6230.,  6680.,  7130.,  7580.,  6296.,  6752.,  7208.,
      7664.,  6362.,  6824.,  7286.,  7748.,  6428.,  6896.,  7364.,  7832.,
      6494.,  6968.,  7442.,  7916.,  6560.,  7040.,  7520.,  8000.,  6626.,
      7112.,  7598.,  8084.,  6692.,  7184.,  7676.,  8168.,  6758.,  7256.,
      7754.,  8252.,  6824.,  7328.,  7832.,  8336.,  8210.,  8840.,  9470.,
      10100., 8276.,  8912.,  9548.,  10184., 8342.,  8984.,  9626.,  10268.,
      8408.,  9056.,  9704.,  10352., 8474.,  9128.,  9782.,  10436., 8540.,
      9200.,  9860.,  10520., 8606.,  9272.,  9938.,  10604., 8672.,  9344.,
      10016., 10688., 8738.,  9416.,  10094., 10772., 8804.,  9488.,  10172.,
      10856., 8870.,  9560.,  10250., 10940., 8936.,  9632.,  10328., 11024.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1312., 1870., 1168., 1592., 2260.,
                                         1408., 882.,  1227., 744.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {335., 356., 377., 440., 461.,
                                         482., 545., 566., 587.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2480., 2624., 3524., 3740., 2192., 2336., 3000., 3184., 4244.,
      4520., 2632., 2816., 1626., 1764., 2247., 2454., 1350., 1488.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      598., 670., 634., 712., 670.,  754., 778.,  880.,  814.,
      922., 850., 964., 958., 1090., 994., 1132., 1030., 1174.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4816., 4960., 5104., 5248., 6832., 7048., 7264., 7480., 4240.,
      4384., 4528., 4672., 5816., 6000., 6184., 6368., 8212., 8488.,
      8764., 9040., 5080., 5264., 5448., 5632., 3114., 3252., 3390.,
      3528., 4287., 4494., 4701., 4908., 2562., 2700., 2838., 2976.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1124., 1196., 1268., 1340., 1190., 1268., 1346., 1424., 1256.,
      1340., 1424., 1508., 1454., 1556., 1658., 1760., 1520., 1628.,
      1736., 1844., 1586., 1700., 1814., 1928., 1784., 1916., 2048.,
      2180., 1850., 1988., 2126., 2264., 1916., 2060., 2204., 2348.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2568., 2624., 3662., 3740., 2288., 2336., 3128., 3184., 4442.,
      4520., 2768., 2816., 1731., 1764., 2409., 2454., 1461., 1488.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      649., 670., 691., 712.,  733.,  754.,  859.,  880.,  901.,
      922., 943., 964., 1069., 1090., 1111., 1132., 1153., 1174.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4856., 5136., 4960., 5248., 6904., 7324., 7048., 7480., 4296.,
      4576., 4384., 4672., 5896., 6256., 6000., 6368., 8344., 8884.,
      8488., 9040., 5176., 5536., 5264., 5632., 3192., 3462., 3252.,
      3528., 4413., 4818., 4494., 4908., 2652., 2922., 2700., 2976.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1160., 1298., 1196., 1340., 1232., 1382., 1268., 1424., 1304.,
      1466., 1340., 1508., 1520., 1718., 1556., 1760., 1592., 1802.,
      1628., 1844., 1664., 1886., 1700., 1928., 1880., 2138., 1916.,
      2180., 1952., 2222., 1988., 2264., 2024., 2306., 2060., 2348.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9432.,  9712.,  9992.,  10272., 9632.,  9920.,  10208., 10496., 13388.,
      13808., 14228., 14648., 13664., 14096., 14528., 14960., 8312.,  8592.,
      8872.,  9152.,  8480.,  8768.,  9056.,  9344.,  11432., 11792., 12152.,
      12512., 11632., 12000., 12368., 12736., 16148., 16688., 17228., 17768.,
      16424., 16976., 17528., 18080., 9992.,  10352., 10712., 11072., 10160.,
      10528., 10896., 11264., 6114.,  6384.,  6654.,  6924.,  6228.,  6504.,
      6780.,  7056.,  8421.,  8826.,  9231.,  9636.,  8574.,  8988.,  9402.,
      9816.,  5034.,  5304.,  5574.,  5844.,  5124.,  5400.,  5676.,  5952.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2182., 2320., 2458., 2596., 2248., 2392., 2536., 2680., 2314.,
      2464., 2614., 2764., 2380., 2536., 2692., 2848., 2446., 2608.,
      2770., 2932., 2512., 2680., 2848., 3016., 2842., 3040., 3238.,
      3436., 2908., 3112., 3316., 3520., 2974., 3184., 3394., 3604.,
      3040., 3256., 3472., 3688., 3106., 3328., 3550., 3772., 3172.,
      3400., 3628., 3856., 3502., 3760., 4018., 4276., 3568., 3832.,
      4096., 4360., 3634., 3904., 4174., 4444., 3700., 3976., 4252.,
      4528., 3766., 4048., 4330., 4612., 3832., 4120., 4408., 4696.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5080., 5136., 5192., 5248., 7246., 7324., 7402., 7480., 4528.,
      4576., 4624., 4672., 6200., 6256., 6312., 6368., 8806., 8884.,
      8962., 9040., 5488., 5536., 5584., 5632., 3429., 3462., 3495.,
      3528., 4773., 4818., 4863., 4908., 2895., 2922., 2949., 2976.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1277., 1298., 1319., 1340., 1361., 1382., 1403., 1424., 1445.,
      1466., 1487., 1508., 1697., 1718., 1739., 1760., 1781., 1802.,
      1823., 1844., 1865., 1886., 1907., 1928., 2117., 2138., 2159.,
      2180., 2201., 2222., 2243., 2264., 2285., 2306., 2327., 2348.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9608.,  10160., 9712.,  10272., 9816.,  10384., 9920.,  10496., 13664.,
      14492., 13808., 14648., 13952., 14804., 14096., 14960., 8504.,  9056.,
      8592.,  9152.,  8680.,  9248.,  8768.,  9344.,  11688., 12400., 11792.,
      12512., 11896., 12624., 12000., 12736., 16544., 17612., 16688., 17768.,
      16832., 17924., 16976., 18080., 10264., 10976., 10352., 11072., 10440.,
      11168., 10528., 11264., 6324.,  6858.,  6384.,  6924.,  6444.,  6990.,
      6504.,  7056.,  8745.,  9546.,  8826.,  9636.,  8907.,  9726.,  8988.,
      9816.,  5256.,  5790.,  5304.,  5844.,  5352.,  5898.,  5400.,  5952.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2284., 2554., 2320., 2596., 2356., 2638., 2392., 2680., 2428.,
      2722., 2464., 2764., 2500., 2806., 2536., 2848., 2572., 2890.,
      2608., 2932., 2644., 2974., 2680., 3016., 3004., 3394., 3040.,
      3436., 3076., 3478., 3112., 3520., 3148., 3562., 3184., 3604.,
      3220., 3646., 3256., 3688., 3292., 3730., 3328., 3772., 3364.,
      3814., 3400., 3856., 3724., 4234., 3760., 4276., 3796., 4318.,
      3832., 4360., 3868., 4402., 3904., 4444., 3940., 4486., 3976.,
      4528., 4012., 4570., 4048., 4612., 4084., 4654., 4120., 4696.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18664., 19216., 19768., 20320., 18864., 19424., 19984., 20544., 19064.,
      19632., 20200., 20768., 19264., 19840., 20416., 20992., 26500., 27328.,
      28156., 28984., 26776., 27616., 28456., 29296., 27052., 27904., 28756.,
      29608., 27328., 28192., 29056., 29920., 16456., 17008., 17560., 18112.,
      16624., 17184., 17744., 18304., 16792., 17360., 17928., 18496., 16960.,
      17536., 18112., 18688., 22664., 23376., 24088., 24800., 22864., 23584.,
      24304., 25024., 23064., 23792., 24520., 25248., 23264., 24000., 24736.,
      25472., 32020., 33088., 34156., 35224., 32296., 33376., 34456., 35536.,
      32572., 33664., 34756., 35848., 32848., 33952., 35056., 36160., 19816.,
      20528., 21240., 21952., 19984., 20704., 21424., 22144., 20152., 20880.,
      21608., 22336., 20320., 21056., 21792., 22528., 12114., 12648., 13182.,
      13716., 12228., 12768., 13308., 13848., 12342., 12888., 13434., 13980.,
      12456., 13008., 13560., 14112., 16689., 17490., 18291., 19092., 16842.,
      17652., 18462., 19272., 16995., 17814., 18633., 19452., 17148., 17976.,
      18804., 19632., 9978.,  10512., 11046., 11580., 10068., 10608., 11148.,
      11688., 10158., 10704., 11250., 11796., 10248., 10800., 11352., 11904.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4298., 4568., 4838., 5108., 4364., 4640., 4916., 5192., 4430., 4712.,
      4994., 5276., 4496., 4784., 5072., 5360., 4562., 4856., 5150., 5444.,
      4628., 4928., 5228., 5528., 4694., 5000., 5306., 5612., 4760., 5072.,
      5384., 5696., 4826., 5144., 5462., 5780., 4892., 5216., 5540., 5864.,
      4958., 5288., 5618., 5948., 5024., 5360., 5696., 6032., 5618., 6008.,
      6398., 6788., 5684., 6080., 6476., 6872., 5750., 6152., 6554., 6956.,
      5816., 6224., 6632., 7040., 5882., 6296., 6710., 7124., 5948., 6368.,
      6788., 7208., 6014., 6440., 6866., 7292., 6080., 6512., 6944., 7376.,
      6146., 6584., 7022., 7460., 6212., 6656., 7100., 7544., 6278., 6728.,
      7178., 7628., 6344., 6800., 7256., 7712., 6938., 7448., 7958., 8468.,
      7004., 7520., 8036., 8552., 7070., 7592., 8114., 8636., 7136., 7664.,
      8192., 8720., 7202., 7736., 8270., 8804., 7268., 7808., 8348., 8888.,
      7334., 7880., 8426., 8972., 7400., 7952., 8504., 9056., 7466., 8024.,
      8582., 9140., 7532., 8096., 8660., 9224., 7598., 8168., 8738., 9308.,
      7664., 8240., 8816., 9392.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2194., 2272., 1420., 2662., 2740.,
                                         1708., 1443., 1488., 903.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {393., 414., 435., 519., 540.,
                                         561., 645., 666., 687.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4136., 4388., 4280., 4544., 2664., 2840., 5000., 5324., 5144.,
      5480., 3192., 3416., 2643., 2886., 2724., 2976., 1638., 1806.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      702.,  786., 738.,  828.,  774.,  870.,  918.,  1038., 954.,
      1080., 990., 1122., 1134., 1290., 1170., 1332., 1206., 1374.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8020.,  8272.,  8524., 8776., 8296.,  8560.,  8824.,  9088., 5152.,
      5328.,  5504.,  5680., 9676., 10000., 10324., 10648., 9952., 10288.,
      10624., 10960., 6160., 6384., 6608.,  6832.,  5043.,  5286., 5529.,
      5772.,  5196.,  5448., 5700., 5952.,  3108.,  3276.,  3444., 3612.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1320., 1404., 1488., 1572., 1386., 1476., 1566., 1656., 1452.,
      1548., 1644., 1740., 1716., 1836., 1956., 2076., 1782., 1908.,
      2034., 2160., 1848., 1980., 2112., 2244., 2112., 2268., 2424.,
      2580., 2178., 2340., 2502., 2664., 2244., 2412., 2580., 2748.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4310., 4388., 4466., 4544., 2792., 2840., 5246., 5324., 5402.,
      5480., 3368., 3416., 2841., 2886., 2931., 2976., 1779., 1806.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      765.,  786.,  807.,  828.,  849.,  870.,  1017., 1038., 1059.,
      1080., 1101., 1122., 1269., 1290., 1311., 1332., 1353., 1374.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8128.,  8620.,  8272., 8776., 8416.,  8932.,  8560.,  9088.,  5240.,
      5584.,  5328.,  5680., 9856., 10492., 10000., 10648., 10144., 10804.,
      10288., 10960., 6296., 6736., 6384.,  6832.,  5205.,  5682.,  5286.,
      5772.,  5367.,  5862., 5448., 5952.,  3228.,  3558.,  3276.,  3612.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1368., 1530., 1404., 1572., 1440., 1614., 1476., 1656., 1512.,
      1698., 1548., 1740., 1800., 2034., 1836., 2076., 1872., 2118.,
      1908., 2160., 1944., 2202., 1980., 2244., 2232., 2538., 2268.,
      2580., 2304., 2622., 2340., 2664., 2376., 2706., 2412., 2748.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15764., 16256., 16748., 17240., 16040., 16544., 17048., 17552., 16316.,
      16832., 17348., 17864., 16592., 17120., 17648., 18176., 10136., 10480.,
      10824., 11168., 10304., 10656., 11008., 11360., 19076., 19712., 20348.,
      20984., 19352., 20000., 20648., 21296., 19628., 20288., 20948., 21608.,
      19904., 20576., 21248., 21920., 12152., 12592., 13032., 13472., 12320.,
      12768., 13216., 13664., 9933.,  10410., 10887., 11364., 10086., 10572.,
      11058., 11544., 10239., 10734., 11229., 11724., 10392., 10896., 11400.,
      11904., 6126.,  6456.,  6786.,  7116.,  6216.,  6552.,  6888.,  7224.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2574., 2736., 2898., 3060., 2640., 2808., 2976., 3144., 2706.,
      2880., 3054., 3228., 2772., 2952., 3132., 3312., 2838., 3024.,
      3210., 3396., 2904., 3096., 3288., 3480., 3366., 3600., 3834.,
      4068., 3432., 3672., 3912., 4152., 3498., 3744., 3990., 4236.,
      3564., 3816., 4068., 4320., 3630., 3888., 4146., 4404., 3696.,
      3960., 4224., 4488., 4158., 4464., 4770., 5076., 4224., 4536.,
      4848., 5160., 4290., 4608., 4926., 5244., 4356., 4680., 5004.,
      5328., 4422., 4752., 5082., 5412., 4488., 4824., 5160., 5496.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8542.,  8620.,  8698., 8776.,  8854.,  8932.,  9010.,  9088.,  5536.,
      5584.,  5632.,  5680., 10414., 10492., 10570., 10648., 10726., 10804.,
      10882., 10960., 6688., 6736.,  6784.,  6832.,  5637.,  5682.,  5727.,
      5772.,  5817.,  5862., 5907.,  5952.,  3531.,  3558.,  3585.,  3612.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1509., 1530., 1551., 1572., 1593., 1614., 1635., 1656., 1677.,
      1698., 1719., 1740., 2013., 2034., 2055., 2076., 2097., 2118.,
      2139., 2160., 2181., 2202., 2223., 2244., 2517., 2538., 2559.,
      2580., 2601., 2622., 2643., 2664., 2685., 2706., 2727., 2748.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16112., 17084., 16256., 17240., 16400., 17396., 16544., 17552., 16688.,
      17708., 16832., 17864., 16976., 18020., 17120., 18176., 10392., 11072.,
      10480., 11168., 10568., 11264., 10656., 11360., 19568., 20828., 19712.,
      20984., 19856., 21140., 20000., 21296., 20144., 21452., 20288., 21608.,
      20432., 21764., 20576., 21920., 12504., 13376., 12592., 13472., 12680.,
      13568., 12768., 13664., 10329., 11274., 10410., 11364., 10491., 11454.,
      10572., 11544., 10653., 11634., 10734., 11724., 10815., 11814., 10896.,
      11904., 6408.,  7062.,  6456.,  7116.,  6504.,  7170.,  6552.,  7224.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2700., 3018., 2736., 3060., 2772., 3102., 2808., 3144., 2844.,
      3186., 2880., 3228., 2916., 3270., 2952., 3312., 2988., 3354.,
      3024., 3396., 3060., 3438., 3096., 3480., 3564., 4026., 3600.,
      4068., 3636., 4110., 3672., 4152., 3708., 4194., 3744., 4236.,
      3780., 4278., 3816., 4320., 3852., 4362., 3888., 4404., 3924.,
      4446., 3960., 4488., 4428., 5034., 4464., 5076., 4500., 5118.,
      4536., 5160., 4572., 5202., 4608., 5244., 4644., 5286., 4680.,
      5328., 4716., 5370., 4752., 5412., 4788., 5454., 4824., 5496.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31252., 32224., 33196., 34168., 31528., 32512., 33496., 34480., 31804.,
      32800., 33796., 34792., 32080., 33088., 34096., 35104., 32356., 33376.,
      34396., 35416., 32632., 33664., 34696., 35728., 32908., 33952., 34996.,
      36040., 33184., 34240., 35296., 36352., 20104., 20784., 21464., 22144.,
      20272., 20960., 21648., 22336., 20440., 21136., 21832., 22528., 20608.,
      21312., 22016., 22720., 37876., 39136., 40396., 41656., 38152., 39424.,
      40696., 41968., 38428., 39712., 40996., 42280., 38704., 40000., 41296.,
      42592., 38980., 40288., 41596., 42904., 39256., 40576., 41896., 43216.,
      39532., 40864., 42196., 43528., 39808., 41152., 42496., 43840., 24136.,
      25008., 25880., 26752., 24304., 25184., 26064., 26944., 24472., 25360.,
      26248., 27136., 24640., 25536., 26432., 27328., 19713., 20658., 21603.,
      22548., 19866., 20820., 21774., 22728., 20019., 20982., 21945., 22908.,
      20172., 21144., 22116., 23088., 20325., 21306., 22287., 23268., 20478.,
      21468., 22458., 23448., 20631., 21630., 22629., 23628., 20784., 21792.,
      22800., 23808., 12162., 12816., 13470., 14124., 12252., 12912., 13572.,
      14232., 12342., 13008., 13674., 14340., 12432., 13104., 13776., 14448.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5082.,  5400.,  5718.,  6036.,  5148.,  5472.,  5796.,  6120.,  5214.,
      5544.,  5874.,  6204.,  5280.,  5616.,  5952.,  6288.,  5346.,  5688.,
      6030.,  6372.,  5412.,  5760.,  6108.,  6456.,  5478.,  5832.,  6186.,
      6540.,  5544.,  5904.,  6264.,  6624.,  5610.,  5976.,  6342.,  6708.,
      5676.,  6048.,  6420.,  6792.,  5742.,  6120.,  6498.,  6876.,  5808.,
      6192.,  6576.,  6960.,  6666.,  7128.,  7590.,  8052.,  6732.,  7200.,
      7668.,  8136.,  6798.,  7272.,  7746.,  8220.,  6864.,  7344.,  7824.,
      8304.,  6930.,  7416.,  7902.,  8388.,  6996.,  7488.,  7980.,  8472.,
      7062.,  7560.,  8058.,  8556.,  7128.,  7632.,  8136.,  8640.,  7194.,
      7704.,  8214.,  8724.,  7260.,  7776.,  8292.,  8808.,  7326.,  7848.,
      8370.,  8892.,  7392.,  7920.,  8448.,  8976.,  8250.,  8856.,  9462.,
      10068., 8316.,  8928.,  9540.,  10152., 8382.,  9000.,  9618.,  10236.,
      8448.,  9072.,  9696.,  10320., 8514.,  9144.,  9774.,  10404., 8580.,
      9216.,  9852.,  10488., 8646.,  9288.,  9930.,  10572., 8712.,  9360.,
      10008., 10656., 8778.,  9432.,  10086., 10740., 8844.,  9504.,  10164.,
      10824., 8910.,  9576.,  10242., 10908., 8976.,  9648.,  10320., 10992.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5128., 5264., 3760., 6216., 6352.,
                                         4528., 3350., 3428., 2394.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1155., 1200., 1245., 1515., 1560.,
                                         1605., 1875., 1920., 1965.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9808.,  10256., 10064., 10528., 7172., 7520., 11856., 12432., 12112.,
      12704., 8612.,  9056.,  6268.,  6700., 6412., 6856.,  4455.,  4788.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139., 2310., 2220., 2400., 2301., 2490., 2787., 3030., 2868.,
      3120., 2949., 3210., 3435., 3750., 3516., 3840., 3597., 3930.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19168., 19616., 20064., 20512., 19664., 20128., 20592., 21056., 13996.,
      14344., 14692., 15040., 23136., 23712., 24288., 24864., 23632., 24224.,
      24816., 25408., 16780., 17224., 17668., 18112., 12104., 12536., 12968.,
      13400., 12380., 12824., 13268., 13712., 8577.,  8910.,  9243.,  9576.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107., 4278., 4449., 4620., 4260., 4440., 4620., 4800., 4413.,
      4602., 4791., 4980., 5331., 5574., 5817., 6060., 5484., 5736.,
      5988., 6240., 5637., 5898., 6159., 6420., 6555., 6870., 7185.,
      7500., 6708., 7032., 7356., 7680., 6861., 7194., 7527., 7860.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10120., 10256., 10392., 10528., 7424., 7520., 12296., 12432., 12568.,
      12704., 8960.,  9056.,  6622.,  6700., 6778., 6856.,  4734.,  4788.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2265., 2310., 2355., 2400., 2445., 2490., 2985., 3030., 3075.,
      3120., 3165., 3210., 3705., 3750., 3795., 3840., 3885., 3930.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19360., 20240., 19616., 20512., 19872., 20784., 20128., 21056., 14164.,
      14848., 14344., 15040., 23456., 24592., 23712., 24864., 23968., 25136.,
      24224., 25408., 17044., 17920., 17224., 18112., 12392., 13244., 12536.,
      13400., 12680., 13556., 12824., 13712., 8811.,  9468.,  8910.,  9576.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4197., 4530., 4278., 4620., 4359., 4710., 4440., 4800., 4521.,
      4890., 4602., 4980., 5493., 5970., 5574., 6060., 5655., 6150.,
      5736., 6240., 5817., 6330., 5898., 6420., 6789., 7410., 6870.,
      7500., 6951., 7590., 7032., 7680., 7113., 7770., 7194., 7860.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37840., 38720., 39600., 40480., 38336., 39232., 40128., 41024., 38832.,
      39744., 40656., 41568., 39328., 40256., 41184., 42112., 27644., 28328.,
      29012., 29696., 27992., 28688., 29384., 30080., 45776., 46912., 48048.,
      49184., 46272., 47424., 48576., 49728., 46768., 47936., 49104., 50272.,
      47264., 48448., 49632., 50816., 33212., 34088., 34964., 35840., 33560.,
      34448., 35336., 36224., 23932., 24784., 25636., 26488., 24208., 25072.,
      25936., 26800., 24484., 25360., 26236., 27112., 24760., 25648., 26536.,
      27424., 16965., 17622., 18279., 18936., 17154., 17820., 18486., 19152.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8394.,  8727.,  9060.,  8214.,  8556.,  8898.,  9240.,  8367.,
      8718.,  9069.,  9420.,  8520.,  8880.,  9240.,  9600.,  8673.,  9042.,
      9411.,  9780.,  8826.,  9204.,  9582.,  9960.,  10509., 10986., 11463.,
      11940., 10662., 11148., 11634., 12120., 10815., 11310., 11805., 12300.,
      10968., 11472., 11976., 12480., 11121., 11634., 12147., 12660., 11274.,
      11796., 12318., 12840., 12957., 13578., 14199., 14820., 13110., 13740.,
      14370., 15000., 13263., 13902., 14541., 15180., 13416., 14064., 14712.,
      15360., 13569., 14226., 14883., 15540., 13722., 14388., 15054., 15720.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20104., 20240., 20376., 20512., 20648., 20784., 20920., 21056., 14752.,
      14848., 14944., 15040., 24456., 24592., 24728., 24864., 25000., 25136.,
      25272., 25408., 17824., 17920., 18016., 18112., 13166., 13244., 13322.,
      13400., 13478., 13556., 13634., 13712., 9414.,  9468.,  9522.,  9576.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4485., 4530., 4575., 4620., 4665., 4710., 4755., 4800., 4845.,
      4890., 4935., 4980., 5925., 5970., 6015., 6060., 6105., 6150.,
      6195., 6240., 6285., 6330., 6375., 6420., 7365., 7410., 7455.,
      7500., 7545., 7590., 7635., 7680., 7725., 7770., 7815., 7860.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38464., 40208., 38720., 40480., 38976., 40752., 39232., 41024., 39488.,
      41296., 39744., 41568., 40000., 41840., 40256., 42112., 28148., 29504.,
      28328., 29696., 28508., 29888., 28688., 30080., 46656., 48912., 46912.,
      49184., 47168., 49456., 47424., 49728., 47680., 50000., 47936., 50272.,
      48192., 50544., 48448., 50816., 33908., 35648., 34088., 35840., 34268.,
      36032., 34448., 36224., 24640., 26332., 24784., 26488., 24928., 26644.,
      25072., 26800., 25216., 26956., 25360., 27112., 25504., 27268., 25648.,
      27424., 17523., 18828., 17622., 18936., 17721., 19044., 17820., 19152.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8313.,  8970.,  8394.,  9060.,  8475.,  9150.,  8556.,  9240.,  8637.,
      9330.,  8718.,  9420.,  8799.,  9510.,  8880.,  9600.,  8961.,  9690.,
      9042.,  9780.,  9123.,  9870.,  9204.,  9960.,  10905., 11850., 10986.,
      11940., 11067., 12030., 11148., 12120., 11229., 12210., 11310., 12300.,
      11391., 12390., 11472., 12480., 11553., 12570., 11634., 12660., 11715.,
      12750., 11796., 12840., 13497., 14730., 13578., 14820., 13659., 14910.,
      13740., 15000., 13821., 15090., 13902., 15180., 13983., 15270., 14064.,
      15360., 14145., 15450., 14226., 15540., 14307., 15630., 14388., 15720.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      75184., 76928., 78672., 80416.,  75680., 77440., 79200., 80960.,
      76176., 77952., 79728., 81504.,  76672., 78464., 80256., 82048.,
      77168., 78976., 80784., 82592.,  77664., 79488., 81312., 83136.,
      78160., 80000., 81840., 83680.,  78656., 80512., 82368., 84224.,
      54940., 56296., 57652., 59008.,  55288., 56656., 58024., 59392.,
      55636., 57016., 58396., 59776.,  55984., 57376., 58768., 60160.,
      91056., 93312., 95568., 97824.,  91552., 93824., 96096., 98368.,
      92048., 94336., 96624., 98912.,  92544., 94848., 97152., 99456.,
      93040., 95360., 97680., 100000., 93536., 95872., 98208., 100544.,
      94032., 96384., 98736., 101088., 94528., 96896., 99264., 101632.,
      66076., 67816., 69556., 71296.,  66424., 68176., 69928., 71680.,
      66772., 68536., 70300., 72064.,  67120., 68896., 70672., 72448.,
      47588., 49280., 50972., 52664.,  47864., 49568., 51272., 52976.,
      48140., 49856., 51572., 53288.,  48416., 50144., 51872., 53600.,
      48692., 50432., 52172., 53912.,  48968., 50720., 52472., 54224.,
      49244., 51008., 52772., 54536.,  49520., 51296., 53072., 54848.,
      33741., 35046., 36351., 37656.,  33930., 35244., 36558., 37872.,
      34119., 35442., 36765., 38088.,  34308., 35640., 36972., 38304.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15969., 16626., 17283., 17940., 16122., 16788., 17454., 18120., 16275.,
      16950., 17625., 18300., 16428., 17112., 17796., 18480., 16581., 17274.,
      17967., 18660., 16734., 17436., 18138., 18840., 16887., 17598., 18309.,
      19020., 17040., 17760., 18480., 19200., 17193., 17922., 18651., 19380.,
      17346., 18084., 18822., 19560., 17499., 18246., 18993., 19740., 17652.,
      18408., 19164., 19920., 20865., 21810., 22755., 23700., 21018., 21972.,
      22926., 23880., 21171., 22134., 23097., 24060., 21324., 22296., 23268.,
      24240., 21477., 22458., 23439., 24420., 21630., 22620., 23610., 24600.,
      21783., 22782., 23781., 24780., 21936., 22944., 23952., 24960., 22089.,
      23106., 24123., 25140., 22242., 23268., 24294., 25320., 22395., 23430.,
      24465., 25500., 22548., 23592., 24636., 25680., 25761., 26994., 28227.,
      29460., 25914., 27156., 28398., 29640., 26067., 27318., 28569., 29820.,
      26220., 27480., 28740., 30000., 26373., 27642., 28911., 30180., 26526.,
      27804., 29082., 30360., 26679., 27966., 29253., 30540., 26832., 28128.,
      29424., 30720., 26985., 28290., 29595., 30900., 27138., 28452., 29766.,
      31080., 27291., 28614., 29937., 31260., 27444., 28776., 30108., 31440.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9192.,  13461., 8736.,  12987., 18990.,
                                         12303., 7824.,  11409., 7368.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3362., 3440., 3518., 3752., 3830.,
                                         3908., 4142., 4220., 4298.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17928., 18384., 26238., 26922., 17016., 17472., 25290., 25974., 36954.,
      37980., 23922., 24606., 15192., 15648., 22134., 22818., 14280., 14736.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6340., 6724., 6484., 6880., 6628., 7036., 7060., 7504., 7204.,
      7660., 7348., 7816., 7780., 8284., 7924., 8440., 8068., 8596.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35400., 35856., 36312., 36768., 51792., 52476., 53160., 53844., 33576.,
      34032., 34488., 34944., 49896., 50580., 51264., 51948., 72882., 73908.,
      74934., 75960., 47160., 47844., 48528., 49212., 29928., 30384., 30840.,
      31296., 43584., 44268., 44952., 45636., 28104., 28560., 29016., 29472.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12296., 12680., 13064., 13448., 12572., 12968., 13364., 13760., 12848.,
      13256., 13664., 14072., 13676., 14120., 14564., 15008., 13952., 14408.,
      14864., 15320., 14228., 14696., 15164., 15632., 15056., 15560., 16064.,
      16568., 15332., 15848., 16364., 16880., 15608., 16136., 16664., 17192.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18192., 18384., 26643., 26922., 17292., 17472., 25713., 25974., 37602.,
      37980., 24363., 24606., 15492., 15648., 22593., 22818., 14592., 14736.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6646., 6724., 6802., 6880., 6958., 7036., 7426., 7504., 7582.,
      7660., 7738., 7816., 8206., 8284., 8362., 8440., 8518., 8596.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35484., 36384., 35856., 36768., 51936., 53286., 52476., 53844., 33684.,
      34584., 34032., 34944., 50076., 51426., 50580., 51948., 73179., 75204.,
      73908., 75960., 47376., 48726., 47844., 49212., 30084., 30984., 30384.,
      31296., 43836., 45186., 44268., 45636., 28284., 29184., 28560., 29472.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12536., 13292., 12680., 13448., 12824., 13604., 12968., 13760., 13112.,
      13916., 13256., 14072., 13976., 14852., 14120., 15008., 14264., 15164.,
      14408., 15320., 14552., 15476., 14696., 15632., 15416., 16412., 15560.,
      16568., 15704., 16724., 15848., 16880., 15992., 17036., 16136., 17192.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      70068.,  70968.,  71868.,  72768.,  70800.,  71712.,  72624.,  73536.,
      102522., 103872., 105222., 106572., 103584., 104952., 106320., 107688.,
      66468.,  67368.,  68268.,  69168.,  67152.,  68064.,  68976.,  69888.,
      98802.,  100152., 101502., 102852., 99792.,  101160., 102528., 103896.,
      144333., 146358., 148383., 150408., 145764., 147816., 149868., 151920.,
      93402.,  94752.,  96102.,  97452.,  94320.,  95688.,  97056.,  98424.,
      59268.,  60168.,  61068.,  61968.,  59856.,  60768.,  61680.,  62592.,
      86322.,  87672.,  89022.,  90372.,  87168.,  88536.,  89904.,  91272.,
      55668.,  56568.,  57468.,  58368.,  56208.,  57120.,  58032.,  58944.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24316., 25072., 25828., 26584., 24592., 25360., 26128., 26896., 24868.,
      25648., 26428., 27208., 25144., 25936., 26728., 27520., 25420., 26224.,
      27028., 27832., 25696., 26512., 27328., 28144., 27076., 27952., 28828.,
      29704., 27352., 28240., 29128., 30016., 27628., 28528., 29428., 30328.,
      27904., 28816., 29728., 30640., 28180., 29104., 30028., 30952., 28456.,
      29392., 30328., 31264., 29836., 30832., 31828., 32824., 30112., 31120.,
      32128., 33136., 30388., 31408., 32428., 33448., 30664., 31696., 32728.,
      33760., 30940., 31984., 33028., 34072., 31216., 32272., 33328., 34384.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36192., 36384., 36576., 36768., 53007., 53286., 53565., 53844., 34404.,
      34584., 34764., 34944., 51165., 51426., 51687., 51948., 74826., 75204.,
      75582., 75960., 48483., 48726., 48969., 49212., 30828., 30984., 31140.,
      31296., 44961., 45186., 45411., 45636., 29040., 29184., 29328., 29472.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13214., 13292., 13370., 13448., 13526., 13604., 13682., 13760., 13838.,
      13916., 13994., 14072., 14774., 14852., 14930., 15008., 15086., 15164.,
      15242., 15320., 15398., 15476., 15554., 15632., 16334., 16412., 16490.,
      16568., 16646., 16724., 16802., 16880., 16958., 17036., 17114., 17192.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      70596.,  72384.,  70968.,  72768.,  71340.,  73152.,  71712.,  73536.,
      103332., 106014., 103872., 106572., 104412., 107130., 104952., 107688.,
      67020.,  68808.,  67368.,  69168.,  67716.,  69528.,  68064.,  69888.,
      99648.,  102330., 100152., 102852., 100656., 103374., 101160., 103896.,
      145629., 149652., 146358., 150408., 147087., 151164., 147816., 151920.,
      94284.,  96966.,  94752.,  97452.,  95220.,  97938.,  95688.,  98424.,
      59868.,  61656.,  60168.,  61968.,  60468.,  62280.,  60768.,  62592.,
      87240.,  89922.,  87672.,  90372.,  88104.,  90822.,  88536.,  91272.,
      56292.,  58080.,  56568.,  58368.,  56844.,  58656.,  57120.,  58944.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24928., 26428., 25072., 26584., 25216., 26740., 25360., 26896., 25504.,
      27052., 25648., 27208., 25792., 27364., 25936., 27520., 26080., 27676.,
      26224., 27832., 26368., 27988., 26512., 28144., 27808., 29548., 27952.,
      29704., 28096., 29860., 28240., 30016., 28384., 30172., 28528., 30328.,
      28672., 30484., 28816., 30640., 28960., 30796., 29104., 30952., 29248.,
      31108., 29392., 31264., 30688., 32668., 30832., 32824., 30976., 32980.,
      31120., 33136., 31264., 33292., 31408., 33448., 31552., 33604., 31696.,
      33760., 31840., 33916., 31984., 34072., 32128., 34228., 32272., 34384.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      139404., 141192., 142980., 144768., 140136., 141936., 143736., 145536.,
      140868., 142680., 144492., 146304., 141600., 143424., 145248., 147072.,
      203982., 206664., 209346., 212028., 205044., 207744., 210444., 213144.,
      206106., 208824., 211542., 214260., 207168., 209904., 212640., 215376.,
      132252., 134040., 135828., 137616., 132936., 134736., 136536., 138336.,
      133620., 135432., 137244., 139056., 134304., 136128., 137952., 139776.,
      196614., 199296., 201978., 204660., 197604., 200304., 203004., 205704.,
      198594., 201312., 204030., 206748., 199584., 202320., 205056., 207792.,
      287235., 291258., 295281., 299304., 288666., 292716., 296766., 300816.,
      290097., 294174., 298251., 302328., 291528., 295632., 299736., 303840.,
      185886., 188568., 191250., 193932., 186804., 189504., 192204., 194904.,
      187722., 190440., 193158., 195876., 188640., 191376., 194112., 196848.,
      117948., 119736., 121524., 123312., 118536., 120336., 122136., 123936.,
      119124., 120936., 122748., 124560., 119712., 121536., 123360., 125184.,
      171798., 174480., 177162., 179844., 172644., 175344., 178044., 180744.,
      173490., 176208., 178926., 181644., 174336., 177072., 179808., 182544.,
      110796., 112584., 114372., 116160., 111336., 113136., 114936., 116736.,
      111876., 113688., 115500., 117312., 112416., 114240., 116064., 117888.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48356., 49856., 51356., 52856., 48632., 50144., 51656., 53168., 48908.,
      50432., 51956., 53480., 49184., 50720., 52256., 53792., 49460., 51008.,
      52556., 54104., 49736., 51296., 52856., 54416., 50012., 51584., 53156.,
      54728., 50288., 51872., 53456., 55040., 50564., 52160., 53756., 55352.,
      50840., 52448., 54056., 55664., 51116., 52736., 54356., 55976., 51392.,
      53024., 54656., 56288., 53876., 55616., 57356., 59096., 54152., 55904.,
      57656., 59408., 54428., 56192., 57956., 59720., 54704., 56480., 58256.,
      60032., 54980., 56768., 58556., 60344., 55256., 57056., 58856., 60656.,
      55532., 57344., 59156., 60968., 55808., 57632., 59456., 61280., 56084.,
      57920., 59756., 61592., 56360., 58208., 60056., 61904., 56636., 58496.,
      60356., 62216., 56912., 58784., 60656., 62528., 59396., 61376., 63356.,
      65336., 59672., 61664., 63656., 65648., 59948., 61952., 63956., 65960.,
      60224., 62240., 64256., 66272., 60500., 62528., 64556., 66584., 60776.,
      62816., 64856., 66896., 61052., 63104., 65156., 67208., 61328., 63392.,
      65456., 67520., 61604., 63680., 65756., 67832., 61880., 63968., 66056.,
      68144., 62156., 64256., 66356., 68456., 62432., 64544., 66656., 68768.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15981., 16260., 10554., 22554., 22932.,
                                         14859., 13551., 13776., 8898.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4002., 4080., 4158., 4470., 4548.,
                                         4626., 4938., 5016., 5094.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31152., 31962., 31692., 32520., 20556., 21108., 43893., 45108., 44622.,
      45864., 28890., 29718., 26292., 27102., 26724., 27552., 17244., 17796.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7548., 8004., 7692., 8160., 7836., 8316., 8412.,  8940., 8556.,
      9096., 8700., 9252., 9276., 9876., 9420., 10032., 9564., 10188.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61494., 62304., 63114., 63924., 62556., 63384., 64212., 65040., 40560.,
      41112., 41664., 42216., 86571., 87786., 89001., 90216., 88002., 89244.,
      90486., 91728., 56952., 57780., 58608., 59436., 51774., 52584., 53394.,
      54204., 52620., 53448., 54276., 55104., 33936., 34488., 35040., 35592.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14640., 15096., 15552., 16008., 14916., 15384., 15852., 16320., 15192.,
      15672., 16152., 16632., 16296., 16824., 17352., 17880., 16572., 17112.,
      17652., 18192., 16848., 17400., 17952., 18504., 17952., 18552., 19152.,
      19752., 18228., 18840., 19452., 20064., 18504., 19128., 19752., 20376.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31683., 31962., 32241., 32520., 20928., 21108., 44730., 45108., 45486.,
      45864., 29475., 29718., 26877., 27102., 27327., 27552., 17652., 17796.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7926., 8004., 8082., 8160., 8238., 8316., 8862.,  8940.,  9018.,
      9096., 9174., 9252., 9798., 9876., 9954., 10032., 10110., 10188.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61764., 63366., 62304., 63924., 62844., 64482., 63384., 65040., 40764.,
      41856., 41112., 42216., 87057., 89460., 87786., 90216., 88515., 90972.,
      89244., 91728., 57312., 58950., 57780., 59436., 52152., 53754., 52584.,
      54204., 53016., 54654., 53448., 55104., 34212., 35304., 34488., 35592.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14952., 15852., 15096., 16008., 15240., 16164., 15384., 16320., 15528.,
      16476., 15672., 16632., 16680., 17724., 16824., 17880., 16968., 18036.,
      17112., 18192., 17256., 18348., 17400., 18504., 18408., 19596., 18552.,
      19752., 18696., 19908., 18840., 20064., 18984., 20220., 19128., 20376.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121926., 123528., 125130., 126732., 122988., 124608., 126228., 127848.,
      124050., 125688., 127326., 128964., 125112., 126768., 128424., 130080.,
      80436.,  81528.,  82620.,  83712.,  81120.,  82224.,  83328.,  84432.,
      171711., 174114., 176517., 178920., 173142., 175572., 178002., 180432.,
      174573., 177030., 179487., 181944., 176004., 178488., 180972., 183456.,
      112986., 114624., 116262., 117900., 113904., 115560., 117216., 118872.,
      102702., 104304., 105906., 107508., 103548., 105168., 106788., 108408.,
      104394., 106032., 107670., 109308., 105240., 106896., 108552., 110208.,
      67332.,  68424.,  69516.,  70608.,  67872.,  68976.,  70080.,  71184.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29004., 29904., 30804., 31704., 29280., 30192., 31104., 32016., 29556.,
      30480., 31404., 32328., 29832., 30768., 31704., 32640., 30108., 31056.,
      32004., 32952., 30384., 31344., 32304., 33264., 32316., 33360., 34404.,
      35448., 32592., 33648., 34704., 35760., 32868., 33936., 35004., 36072.,
      33144., 34224., 35304., 36384., 33420., 34512., 35604., 36696., 33696.,
      34800., 35904., 37008., 35628., 36816., 38004., 39192., 35904., 37104.,
      38304., 39504., 36180., 37392., 38604., 39816., 36456., 37680., 38904.,
      40128., 36732., 37968., 39204., 40440., 37008., 38256., 39504., 40752.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63087., 63366., 63645., 63924., 64203., 64482., 64761., 65040., 41676.,
      41856., 42036., 42216., 89082., 89460., 89838., 90216., 90594., 90972.,
      91350., 91728., 58707., 58950., 59193., 59436., 53529., 53754., 53979.,
      54204., 54429., 54654., 54879., 55104., 35160., 35304., 35448., 35592.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15774., 15852., 15930., 16008., 16086., 16164., 16242., 16320., 16398.,
      16476., 16554., 16632., 17646., 17724., 17802., 17880., 17958., 18036.,
      18114., 18192., 18270., 18348., 18426., 18504., 19518., 19596., 19674.,
      19752., 19830., 19908., 19986., 20064., 20142., 20220., 20298., 20376.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      122988., 126174., 123528., 126732., 124068., 127290., 124608., 127848.,
      125148., 128406., 125688., 128964., 126228., 129522., 126768., 130080.,
      81180.,  83352.,  81528.,  83712.,  81876.,  84072.,  82224.,  84432.,
      173385., 178164., 174114., 178920., 174843., 179676., 175572., 180432.,
      176301., 181188., 177030., 181944., 177759., 182700., 178488., 183456.,
      114156., 117414., 114624., 117900., 115092., 118386., 115560., 118872.,
      103872., 107058., 104304., 107508., 104736., 107958., 105168., 108408.,
      105600., 108858., 106032., 109308., 106464., 109758., 106896., 110208.,
      68148.,  70320.,  68424.,  70608.,  68700.,  70896.,  68976.,  71184.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29760., 31548., 29904., 31704., 30048., 31860., 30192., 32016., 30336.,
      32172., 30480., 32328., 30624., 32484., 30768., 32640., 30912., 32796.,
      31056., 32952., 31200., 33108., 31344., 33264., 33216., 35292., 33360.,
      35448., 33504., 35604., 33648., 35760., 33792., 35916., 33936., 36072.,
      34080., 36228., 34224., 36384., 34368., 36540., 34512., 36696., 34656.,
      36852., 34800., 37008., 36672., 39036., 36816., 39192., 36960., 39348.,
      37104., 39504., 37248., 39660., 37392., 39816., 37536., 39972., 37680.,
      40128., 37824., 40284., 37968., 40440., 38112., 40596., 38256., 40752.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      242790., 245976., 249162., 252348., 243852., 247056., 250260., 253464.,
      244914., 248136., 251358., 254580., 245976., 249216., 252456., 255696.,
      247038., 250296., 253554., 256812., 248100., 251376., 254652., 257928.,
      249162., 252456., 255750., 259044., 250224., 253536., 256848., 260160.,
      160188., 162360., 164532., 166704., 160872., 163056., 165240., 167424.,
      161556., 163752., 165948., 168144., 162240., 164448., 166656., 168864.,
      341991., 346770., 351549., 356328., 343422., 348228., 353034., 357840.,
      344853., 349686., 354519., 359352., 346284., 351144., 356004., 360864.,
      347715., 352602., 357489., 362376., 349146., 354060., 358974., 363888.,
      350577., 355518., 360459., 365400., 352008., 356976., 361944., 366912.,
      225054., 228312., 231570., 234828., 225972., 229248., 232524., 235800.,
      226890., 230184., 233478., 236772., 227808., 231120., 234432., 237744.,
      204558., 207744., 210930., 214116., 205404., 208608., 211812., 215016.,
      206250., 209472., 212694., 215916., 207096., 210336., 213576., 216816.,
      207942., 211200., 214458., 217716., 208788., 212064., 215340., 218616.,
      209634., 212928., 216222., 219516., 210480., 213792., 217104., 220416.,
      134124., 136296., 138468., 140640., 134664., 136848., 139032., 141216.,
      135204., 137400., 139596., 141792., 135744., 137952., 140160., 142368.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57732., 59520., 61308., 63096., 58008., 59808., 61608., 63408., 58284.,
      60096., 61908., 63720., 58560., 60384., 62208., 64032., 58836., 60672.,
      62508., 64344., 59112., 60960., 62808., 64656., 59388., 61248., 63108.,
      64968., 59664., 61536., 63408., 65280., 59940., 61824., 63708., 65592.,
      60216., 62112., 64008., 65904., 60492., 62400., 64308., 66216., 60768.,
      62688., 64608., 66528., 64356., 66432., 68508., 70584., 64632., 66720.,
      68808., 70896., 64908., 67008., 69108., 71208., 65184., 67296., 69408.,
      71520., 65460., 67584., 69708., 71832., 65736., 67872., 70008., 72144.,
      66012., 68160., 70308., 72456., 66288., 68448., 70608., 72768., 66564.,
      68736., 70908., 73080., 66840., 69024., 71208., 73392., 67116., 69312.,
      71508., 73704., 67392., 69600., 71808., 74016., 70980., 73344., 75708.,
      78072., 71256., 73632., 76008., 78384., 71532., 73920., 76308., 78696.,
      71808., 74208., 76608., 79008., 72084., 74496., 76908., 79320., 72360.,
      74784., 77208., 79632., 72636., 75072., 77508., 79944., 72912., 75360.,
      77808., 80256., 73188., 75648., 78108., 80568., 73464., 75936., 78408.,
      80880., 73740., 76224., 78708., 81192., 74016., 76512., 79008., 81504.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37644., 38136., 28032., 53106., 53772.,
                                         39474., 31884., 32280., 23640.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11841., 12012., 12183., 13209., 13380.,
                                         13551., 14577., 14748., 14919.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73848.,  75288.,  74808.,  76272.,  54966., 56064.,
      104052., 106212., 105348., 107544., 77301., 78948.,
      62328.,  63768.,  63096.,  64560.,  46182., 47280.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22764., 23682., 23088., 24024., 23412., 24366., 25356., 26418., 25680.,
      26760., 26004., 27102., 27948., 29154., 28272., 29496., 28596., 29838.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      146256., 147696., 149136., 150576., 148152., 149616., 151080., 152544.,
      108834., 109932., 111030., 112128., 205944., 208104., 210264., 212424.,
      208500., 210696., 212892., 215088., 152955., 154602., 156249., 157896.,
      123216., 124656., 126096., 127536., 124728., 126192., 127656., 129120.,
      91266.,  92364.,  93462.,  94560.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44610., 45528., 46446., 47364., 45240., 46176., 47112., 48048., 45870.,
      46824., 47778., 48732., 49650., 50712., 51774., 52836., 50280., 51360.,
      52440., 53520., 50910., 52008., 53106., 54204., 54690., 55896., 57102.,
      58308., 55320., 56544., 57768., 58992., 55950., 57192., 58434., 59676.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74796.,  75288.,  75780.,  76272.,  55704., 56064.,
      105546., 106212., 106878., 107544., 78462., 78948.,
      63372.,  63768.,  64164.,  64560.,  46992., 47280.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23511., 23682., 23853., 24024., 24195., 24366., 26247., 26418., 26589.,
      26760., 26931., 27102., 28983., 29154., 29325., 29496., 29667., 29838.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      146736., 149592., 147696., 150576., 148656., 151560., 149616., 152544.,
      109230., 111408., 109932., 112128., 206808., 211092., 208104., 212424.,
      209400., 213756., 210696., 215088., 153657., 156924., 154602., 157896.,
      123888., 126744., 124656., 127536., 125424., 128328., 126192., 129120.,
      91806.,  93984.,  92364.,  94560.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45204., 47022., 45528., 47364., 45852., 47706., 46176., 48048., 46500.,
      48390., 46824., 48732., 50388., 52494., 50712., 52836., 51036., 53178.,
      51360., 53520., 51684., 53862., 52008., 54204., 55572., 57966., 55896.,
      58308., 56220., 58650., 56544., 58992., 56868., 59334., 57192., 59676.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      290616., 293472., 296328., 299184., 292512., 295392., 298272., 301152.,
      294408., 297312., 300216., 303120., 296304., 299232., 302160., 305088.,
      216282., 218460., 220638., 222816., 217668., 219864., 222060., 224256.,
      409332., 413616., 417900., 422184., 411888., 416208., 420528., 424848.,
      414444., 418800., 423156., 427512., 417000., 421392., 425784., 430176.,
      304047., 307314., 310581., 313848., 305910., 309204., 312498., 315792.,
      244920., 247776., 250632., 253488., 246432., 249312., 252192., 255072.,
      247944., 250848., 253752., 256656., 249456., 252384., 255312., 258240.,
      181434., 183612., 185790., 187968., 182532., 184728., 186924., 189120.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      88590.,  90408.,  92226.,  94044.,  89220.,  91056.,  92892.,  94728.,
      89850.,  91704.,  93558.,  95412.,  90480.,  92352.,  94224.,  96096.,
      91110.,  93000.,  94890.,  96780.,  91740.,  93648.,  95556.,  97464.,
      98670.,  100776., 102882., 104988., 99300.,  101424., 103548., 105672.,
      99930.,  102072., 104214., 106356., 100560., 102720., 104880., 107040.,
      101190., 103368., 105546., 107724., 101820., 104016., 106212., 108408.,
      108750., 111144., 113538., 115932., 109380., 111792., 114204., 116616.,
      110010., 112440., 114870., 117300., 110640., 113088., 115536., 117984.,
      111270., 113736., 116202., 118668., 111900., 114384., 116868., 119352.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149100., 149592., 150084., 150576., 151068., 151560., 152052., 152544.,
      111048., 111408., 111768., 112128., 210426., 211092., 211758., 212424.,
      213090., 213756., 214422., 215088., 156438., 156924., 157410., 157896.,
      126348., 126744., 127140., 127536., 127932., 128328., 128724., 129120.,
      93696.,  93984.,  94272.,  94560.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46851., 47022., 47193., 47364., 47535., 47706., 47877., 48048., 48219.,
      48390., 48561., 48732., 52323., 52494., 52665., 52836., 53007., 53178.,
      53349., 53520., 53691., 53862., 54033., 54204., 57795., 57966., 58137.,
      58308., 58479., 58650., 58821., 58992., 59163., 59334., 59505., 59676.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      292512., 298200., 293472., 299184., 294432., 300168., 295392., 301152.,
      296352., 302136., 297312., 303120., 298272., 304104., 299232., 305088.,
      217758., 222096., 218460., 222816., 219162., 223536., 219864., 224256.,
      412320., 420852., 413616., 422184., 414912., 423516., 416208., 424848.,
      417504., 426180., 418800., 427512., 420096., 428844., 421392., 430176.,
      306369., 312876., 307314., 313848., 308259., 314820., 309204., 315792.,
      247008., 252696., 247776., 253488., 248544., 254280., 249312., 255072.,
      250080., 255864., 250848., 256656., 251616., 257448., 252384., 258240.,
      183054., 187392., 183612., 187968., 184170., 188544., 184728., 189120.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90084.,  93702.,  90408.,  94044.,  90732.,  94386.,  91056.,  94728.,
      91380.,  95070.,  91704.,  95412.,  92028.,  95754.,  92352.,  96096.,
      92676.,  96438.,  93000.,  96780.,  93324.,  97122.,  93648.,  97464.,
      100452., 104646., 100776., 104988., 101100., 105330., 101424., 105672.,
      101748., 106014., 102072., 106356., 102396., 106698., 102720., 107040.,
      103044., 107382., 103368., 107724., 103692., 108066., 104016., 108408.,
      110820., 115590., 111144., 115932., 111468., 116274., 111792., 116616.,
      112116., 116958., 112440., 117300., 112764., 117642., 113088., 117984.,
      113412., 118326., 113736., 118668., 114060., 119010., 114384., 119352.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      579336., 585024., 590712., 596400., 581232., 586944., 592656., 598368.,
      583128., 588864., 594600., 600336., 585024., 590784., 596544., 602304.,
      586920., 592704., 598488., 604272., 588816., 594624., 600432., 606240.,
      590712., 596544., 602376., 608208., 592608., 598464., 604320., 610176.,
      431178., 435516., 439854., 444192., 432564., 436920., 441276., 445632.,
      433950., 438324., 442698., 447072., 435336., 439728., 444120., 448512.,
      816108., 824640., 833172., 841704., 818664., 827232., 835800., 844368.,
      821220., 829824., 838428., 847032., 823776., 832416., 841056., 849696.,
      826332., 835008., 843684., 852360., 828888., 837600., 846312., 855024.,
      831444., 840192., 848940., 857688., 834000., 842784., 851568., 860352.,
      606231., 612738., 619245., 625752., 608094., 614628., 621162., 627696.,
      609957., 616518., 623079., 629640., 611820., 618408., 624996., 631584.,
      488328., 494016., 499704., 505392., 489840., 495552., 501264., 506976.,
      491352., 497088., 502824., 508560., 492864., 498624., 504384., 510144.,
      494376., 500160., 505944., 511728., 495888., 501696., 507504., 513312.,
      497400., 503232., 509064., 514896., 498912., 504768., 510624., 516480.,
      361770., 366108., 370446., 374784., 362868., 367224., 371580., 375936.,
      363966., 368340., 372714., 377088., 365064., 369456., 373848., 378240.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      176550., 180168., 183786., 187404., 177180., 180816., 184452., 188088.,
      177810., 181464., 185118., 188772., 178440., 182112., 185784., 189456.,
      179070., 182760., 186450., 190140., 179700., 183408., 187116., 190824.,
      180330., 184056., 187782., 191508., 180960., 184704., 188448., 192192.,
      181590., 185352., 189114., 192876., 182220., 186000., 189780., 193560.,
      182850., 186648., 190446., 194244., 183480., 187296., 191112., 194928.,
      196710., 200904., 205098., 209292., 197340., 201552., 205764., 209976.,
      197970., 202200., 206430., 210660., 198600., 202848., 207096., 211344.,
      199230., 203496., 207762., 212028., 199860., 204144., 208428., 212712.,
      200490., 204792., 209094., 213396., 201120., 205440., 209760., 214080.,
      201750., 206088., 210426., 214764., 202380., 206736., 211092., 215448.,
      203010., 207384., 211758., 216132., 203640., 208032., 212424., 216816.,
      216870., 221640., 226410., 231180., 217500., 222288., 227076., 231864.,
      218130., 222936., 227742., 232548., 218760., 223584., 228408., 233232.,
      219390., 224232., 229074., 233916., 220020., 224880., 229740., 234600.,
      220650., 225528., 230406., 235284., 221280., 226176., 231072., 235968.,
      221910., 226824., 231738., 236652., 222540., 227472., 232404., 237336.,
      223170., 228120., 233070., 238020., 223800., 228768., 233736., 238704.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14832., 21690., 14058., 16137., 23580.,
                                         15273., 9744.,  14199., 9168.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3912., 3990., 4068., 4302., 4380.,
                                         4458., 4692., 4770., 4848.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28890., 29664., 42219., 43380., 27342., 28116., 31410., 32274., 45864.,
      47160., 29682., 30546., 18912., 19488., 27534., 28398., 17760., 18336.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7380., 7824., 7524., 7980., 7668., 8136., 8100., 8604., 8244.,
      8760., 8388., 8916., 8820., 9384., 8964., 9540., 9108., 9696.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57006., 57780., 58554., 59328., 83277., 84438., 85599., 86760., 53910.,
      54684., 55458., 56232., 61956., 62820., 63684., 64548., 90432., 91728.,
      93024., 94320., 58500., 59364., 60228., 61092., 37248., 37824., 38400.,
      38976., 54204., 55068., 55932., 56796., 34944., 35520., 36096., 36672.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14316., 14760., 15204., 15648., 14592., 15048., 15504., 15960., 14868.,
      15336., 15804., 16272., 15696., 16200., 16704., 17208., 15972., 16488.,
      17004., 17520., 16248., 16776., 17304., 17832., 17076., 17640., 18204.,
      18768., 17352., 17928., 18504., 19080., 17628., 18216., 18804., 19392.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29403., 29664., 43002., 43380., 27873., 28116., 32013., 32274., 46782.,
      47160., 30303., 30546., 19332., 19488., 28173., 28398., 18192., 18336.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7746., 7824., 7902., 7980., 8058., 8136., 8526., 8604., 8682.,
      8760., 8838., 8916., 9306., 9384., 9462., 9540., 9618., 9696.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57276., 58806., 57780., 59328., 83709., 86004., 84438., 86760., 54216.,
      55746., 54684., 56232., 62316., 64026., 62820., 64548., 90999., 93564.,
      91728., 94320., 58896., 60606., 59364., 61092., 37524., 38664., 37824.,
      38976., 54636., 56346., 55068., 56796., 35244., 36384., 35520., 36672.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14616., 15492., 14760., 15648., 14904., 15804., 15048., 15960., 15192.,
      16116., 15336., 16272., 16056., 17052., 16200., 17208., 16344., 17364.,
      16488., 17520., 16632., 17676., 16776., 17832., 17496., 18612., 17640.,
      18768., 17784., 18924., 17928., 19080., 18072., 19236., 18216., 19392.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113022., 114552., 116082., 117612., 114012., 115560., 117108., 118656.,
      165123., 167418., 169713., 172008., 166554., 168876., 171198., 173520.,
      106902., 108432., 109962., 111492., 107820., 109368., 110916., 112464.,
      122922., 124632., 126342., 128052., 123912., 125640., 127368., 129096.,
      179433., 181998., 184563., 187128., 180864., 183456., 186048., 188640.,
      116082., 117792., 119502., 121212., 117000., 118728., 120456., 122184.,
      73908.,  75048.,  76188.,  77328.,  74496.,  75648.,  76800.,  77952.,
      107562., 109272., 110982., 112692., 108408., 110136., 111864., 113592.,
      69348.,  70488.,  71628.,  72768.,  69888.,  71040.,  72192.,  73344.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28356., 29232., 30108., 30984., 28632., 29520., 30408., 31296., 28908.,
      29808., 30708., 31608., 29184., 30096., 31008., 31920., 29460., 30384.,
      31308., 32232., 29736., 30672., 31608., 32544., 31116., 32112., 33108.,
      34104., 31392., 32400., 33408., 34416., 31668., 32688., 33708., 34728.,
      31944., 32976., 34008., 35040., 32220., 33264., 34308., 35352., 32496.,
      33552., 34608., 35664., 33876., 34992., 36108., 37224., 34152., 35280.,
      36408., 37536., 34428., 35568., 36708., 37848., 34704., 35856., 37008.,
      38160., 34980., 36144., 37308., 38472., 35256., 36432., 37608., 38784.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58545., 58806., 59067., 59328., 85626., 86004., 86382., 86760., 55503.,
      55746., 55989., 56232., 63765., 64026., 64287., 64548., 93186., 93564.,
      93942., 94320., 60363., 60606., 60849., 61092., 38508., 38664., 38820.,
      38976., 56121., 56346., 56571., 56796., 36240., 36384., 36528., 36672.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15414., 15492., 15570., 15648., 15726., 15804., 15882., 15960., 16038.,
      16116., 16194., 16272., 16974., 17052., 17130., 17208., 17286., 17364.,
      17442., 17520., 17598., 17676., 17754., 17832., 18534., 18612., 18690.,
      18768., 18846., 18924., 19002., 19080., 19158., 19236., 19314., 19392.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      114048., 117090., 114552., 117612., 115056., 118134., 115560., 118656.,
      166689., 171252., 167418., 172008., 168147., 172764., 168876., 173520.,
      107964., 111006., 108432., 111492., 108900., 111978., 109368., 112464.,
      124128., 127530., 124632., 128052., 125136., 128574., 125640., 129096.,
      181269., 186372., 181998., 187128., 182727., 187884., 183456., 188640.,
      117324., 120726., 117792., 121212., 118260., 121698., 118728., 122184.,
      74748.,  77016.,  75048.,  77328.,  75348.,  77640.,  75648.,  77952.,
      108840., 112242., 109272., 112692., 109704., 113142., 110136., 113592.,
      70212.,  72480.,  70488.,  72768.,  70764.,  73056.,  71040.,  73344.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29088., 30828., 29232., 30984., 29376., 31140., 29520., 31296., 29664.,
      31452., 29808., 31608., 29952., 31764., 30096., 31920., 30240., 32076.,
      30384., 32232., 30528., 32388., 30672., 32544., 31968., 33948., 32112.,
      34104., 32256., 34260., 32400., 34416., 32544., 34572., 32688., 34728.,
      32832., 34884., 32976., 35040., 33120., 35196., 33264., 35352., 33408.,
      35508., 33552., 35664., 34848., 37068., 34992., 37224., 35136., 37380.,
      35280., 37536., 35424., 37692., 35568., 37848., 35712., 38004., 35856.,
      38160., 36000., 38316., 36144., 38472., 36288., 38628., 36432., 38784.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      225054., 228096., 231138., 234180., 226044., 229104., 232164., 235224.,
      227034., 230112., 233190., 236268., 228024., 231120., 234216., 237312.,
      328815., 333378., 337941., 342504., 330246., 334836., 339426., 344016.,
      331677., 336294., 340911., 345528., 333108., 337752., 342396., 347040.,
      212886., 215928., 218970., 222012., 213804., 216864., 219924., 222984.,
      214722., 217800., 220878., 223956., 215640., 218736., 221832., 224928.,
      244854., 248256., 251658., 255060., 245844., 249264., 252684., 256104.,
      246834., 250272., 253710., 257148., 247824., 251280., 254736., 258192.,
      357435., 362538., 367641., 372744., 358866., 363996., 369126., 374256.,
      360297., 365454., 370611., 375768., 361728., 366912., 372096., 377280.,
      231246., 234648., 238050., 241452., 232164., 235584., 239004., 242424.,
      233082., 236520., 239958., 243396., 234000., 237456., 240912., 244368.,
      147228., 149496., 151764., 154032., 147816., 150096., 152376., 154656.,
      148404., 150696., 152988., 155280., 148992., 151296., 153600., 155904.,
      214278., 217680., 221082., 224484., 215124., 218544., 221964., 225384.,
      215970., 219408., 222846., 226284., 216816., 220272., 223728., 227184.,
      138156., 140424., 142692., 144960., 138696., 140976., 143256., 145536.,
      139236., 141528., 143820., 146112., 139776., 142080., 144384., 146688.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      56436., 58176., 59916., 61656., 56712., 58464., 60216., 61968., 56988.,
      58752., 60516., 62280., 57264., 59040., 60816., 62592., 57540., 59328.,
      61116., 62904., 57816., 59616., 61416., 63216., 58092., 59904., 61716.,
      63528., 58368., 60192., 62016., 63840., 58644., 60480., 62316., 64152.,
      58920., 60768., 62616., 64464., 59196., 61056., 62916., 64776., 59472.,
      61344., 63216., 65088., 61956., 63936., 65916., 67896., 62232., 64224.,
      66216., 68208., 62508., 64512., 66516., 68520., 62784., 64800., 66816.,
      68832., 63060., 65088., 67116., 69144., 63336., 65376., 67416., 69456.,
      63612., 65664., 67716., 69768., 63888., 65952., 68016., 70080., 64164.,
      66240., 68316., 70392., 64440., 66528., 68616., 70704., 64716., 66816.,
      68916., 71016., 64992., 67104., 69216., 71328., 67476., 69696., 71916.,
      74136., 67752., 69984., 72216., 74448., 68028., 70272., 72516., 74760.,
      68304., 70560., 72816., 75072., 68580., 70848., 73116., 75384., 68856.,
      71136., 73416., 75696., 69132., 71424., 73716., 76008., 69408., 71712.,
      74016., 76320., 69684., 72000., 74316., 76632., 69960., 72288., 74616.,
      76944., 70236., 72576., 74916., 77256., 70512., 72864., 75216., 77568.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25794., 26172., 16965., 28062., 28440.,
                                         18423., 16899., 17124., 11058.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4662., 4740., 4818., 5130., 5208.,
                                         5286., 5598., 5676., 5754.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50211., 51588., 50940., 52344., 32994., 33930., 54585., 56124., 55314.,
      56880., 35802., 36846., 32772., 33798., 33204., 34248., 21420., 22116.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8796.,  9324., 8940.,  9480.,  9084.,  9636.,  9660.,  10260., 9804.,
      10416., 9948., 10572., 10524., 11196., 10668., 11352., 10812., 11508.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      99045.,  100422., 101799., 103176., 100476., 101880., 103284., 104688.,
      65052.,  65988.,  66924.,  67860.,  107631., 109170., 110709., 112248.,
      109062., 110628., 112194., 113760., 70560.,  71604.,  72648.,  73692.,
      64518.,  65544.,  66570.,  67596.,  65364.,  66408.,  67452.,  68496.,
      42144.,  42840.,  43536.,  44232.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17064., 17592., 18120., 18648., 17340., 17880., 18420., 18960., 17616.,
      18168., 18720., 19272., 18720., 19320., 19920., 20520., 18996., 19608.,
      20220., 20832., 19272., 19896., 20520., 21144., 20376., 21048., 21720.,
      22392., 20652., 21336., 22020., 22704., 20928., 21624., 22320., 23016.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      51210., 51588., 51966., 52344., 33687., 33930., 55746., 56124., 56502.,
      56880., 36603., 36846., 33573., 33798., 34023., 34248., 21972., 22116.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9246.,  9324.,  9402.,  9480.,  9558.,  9636.,  10182., 10260., 10338.,
      10416., 10494., 10572., 11118., 11196., 11274., 11352., 11430., 11508.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      99693.,  102420., 100422., 103176., 101151., 103932., 101880., 104688.,
      65520.,  67374.,  65988.,  67860.,  108441., 111492., 109170., 112248.,
      109899., 113004., 110628., 113760., 71136.,  73206.,  71604.,  73692.,
      65112.,  67146.,  65544.,  67596.,  65976.,  68046.,  66408.,  68496.,
      42564.,  43944.,  42840.,  44232.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17448., 18492., 17592., 18648., 17736., 18804., 17880., 18960., 18024.,
      19116., 18168., 19272., 19176., 20364., 19320., 20520., 19464., 20676.,
      19608., 20832., 19752., 20988., 19896., 21144., 20904., 22236., 21048.,
      22392., 21192., 22548., 21336., 22704., 21480., 22860., 21624., 23016.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      196659., 199386., 202113., 204840., 198090., 200844., 203598., 206352.,
      199521., 202302., 205083., 207864., 200952., 203760., 206568., 209376.,
      129186., 131040., 132894., 134748., 130104., 131976., 133848., 135720.,
      213831., 216882., 219933., 222984., 215262., 218340., 221418., 224496.,
      216693., 219798., 222903., 226008., 218124., 221256., 224388., 227520.,
      140202., 142272., 144342., 146412., 141120., 143208., 145296., 147384.,
      128190., 130224., 132258., 134292., 129036., 131088., 133140., 135192.,
      129882., 131952., 134022., 136092., 130728., 132816., 134904., 136992.,
      83748.,  85128.,  86508.,  87888.,  84288.,  85680.,  87072.,  88464.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33852., 34896., 35940., 36984., 34128., 35184., 36240., 37296., 34404.,
      35472., 36540., 37608., 34680., 35760., 36840., 37920., 34956., 36048.,
      37140., 38232., 35232., 36336., 37440., 38544., 37164., 38352., 39540.,
      40728., 37440., 38640., 39840., 41040., 37716., 38928., 40140., 41352.,
      37992., 39216., 40440., 41664., 38268., 39504., 40740., 41976., 38544.,
      39792., 41040., 42288., 40476., 41808., 43140., 44472., 40752., 42096.,
      43440., 44784., 41028., 42384., 43740., 45096., 41304., 42672., 44040.,
      45408., 41580., 42960., 44340., 45720., 41856., 43248., 44640., 46032.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      102042., 102420., 102798., 103176., 103554., 103932., 104310., 104688.,
      67131.,  67374.,  67617.,  67860.,  111114., 111492., 111870., 112248.,
      112626., 113004., 113382., 113760., 72963.,  73206.,  73449.,  73692.,
      66921.,  67146.,  67371.,  67596.,  67821.,  68046.,  68271.,  68496.,
      43800.,  43944.,  44088.,  44232.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18414., 18492., 18570., 18648., 18726., 18804., 18882., 18960., 19038.,
      19116., 19194., 19272., 20286., 20364., 20442., 20520., 20598., 20676.,
      20754., 20832., 20910., 20988., 21066., 21144., 22158., 22236., 22314.,
      22392., 22470., 22548., 22626., 22704., 22782., 22860., 22938., 23016.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      198657., 204084., 199386., 204840., 200115., 205596., 200844., 206352.,
      201573., 207108., 202302., 207864., 203031., 208620., 203760., 209376.,
      130572., 134262., 131040., 134748., 131508., 135234., 131976., 135720.,
      216153., 222228., 216882., 222984., 217611., 223740., 218340., 224496.,
      219069., 225252., 219798., 226008., 220527., 226764., 221256., 227520.,
      141804., 145926., 142272., 146412., 142740., 146898., 143208., 147384.,
      129792., 133842., 130224., 134292., 130656., 134742., 131088., 135192.,
      131520., 135642., 131952., 136092., 132384., 136542., 132816., 136992.,
      84852.,  87600.,  85128.,  87888.,  85404.,  88176.,  85680.,  88464.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34752., 36828., 34896., 36984., 35040., 37140., 35184., 37296., 35328.,
      37452., 35472., 37608., 35616., 37764., 35760., 37920., 35904., 38076.,
      36048., 38232., 36192., 38388., 36336., 38544., 38208., 40572., 38352.,
      40728., 38496., 40884., 38640., 41040., 38784., 41196., 38928., 41352.,
      39072., 41508., 39216., 41664., 39360., 41820., 39504., 41976., 39648.,
      42132., 39792., 42288., 41664., 44316., 41808., 44472., 41952., 44628.,
      42096., 44784., 42240., 44940., 42384., 45096., 42528., 45252., 42672.,
      45408., 42816., 45564., 42960., 45720., 43104., 45876., 43248., 46032.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      391887., 397314., 402741., 408168., 393318., 398772., 404226., 409680.,
      394749., 400230., 405711., 411192., 396180., 401688., 407196., 412704.,
      397611., 403146., 408681., 414216., 399042., 404604., 410166., 415728.,
      400473., 406062., 411651., 417240., 401904., 407520., 413136., 418752.,
      257454., 261144., 264834., 268524., 258372., 262080., 265788., 269496.,
      259290., 263016., 266742., 270468., 260208., 263952., 267696., 271440.,
      426231., 432306., 438381., 444456., 427662., 433764., 439866., 445968.,
      429093., 435222., 441351., 447480., 430524., 436680., 442836., 448992.,
      431955., 438138., 444321., 450504., 433386., 439596., 445806., 452016.,
      434817., 441054., 447291., 453528., 436248., 442512., 448776., 455040.,
      279486., 283608., 287730., 291852., 280404., 284544., 288684., 292824.,
      281322., 285480., 289638., 293796., 282240., 286416., 290592., 294768.,
      255534., 259584., 263634., 267684., 256380., 260448., 264516., 268584.,
      257226., 261312., 265398., 269484., 258072., 262176., 266280., 270384.,
      258918., 263040., 267162., 271284., 259764., 263904., 268044., 272184.,
      260610., 264768., 268926., 273084., 261456., 265632., 269808., 273984.,
      166956., 169704., 172452., 175200., 167496., 170256., 173016., 175776.,
      168036., 170808., 173580., 176352., 168576., 171360., 174144., 176928.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67428., 69504., 71580., 73656., 67704., 69792., 71880., 73968., 67980.,
      70080., 72180., 74280., 68256., 70368., 72480., 74592., 68532., 70656.,
      72780., 74904., 68808., 70944., 73080., 75216., 69084., 71232., 73380.,
      75528., 69360., 71520., 73680., 75840., 69636., 71808., 73980., 76152.,
      69912., 72096., 74280., 76464., 70188., 72384., 74580., 76776., 70464.,
      72672., 74880., 77088., 74052., 76416., 78780., 81144., 74328., 76704.,
      79080., 81456., 74604., 76992., 79380., 81768., 74880., 77280., 79680.,
      82080., 75156., 77568., 79980., 82392., 75432., 77856., 80280., 82704.,
      75708., 78144., 80580., 83016., 75984., 78432., 80880., 83328., 76260.,
      78720., 81180., 83640., 76536., 79008., 81480., 83952., 76812., 79296.,
      81780., 84264., 77088., 79584., 82080., 84576., 80676., 83328., 85980.,
      88632., 80952., 83616., 86280., 88944., 81228., 83904., 86580., 89256.,
      81504., 84192., 86880., 89568., 81780., 84480., 87180., 89880., 82056.,
      84768., 87480., 90192., 82332., 85056., 87780., 90504., 82608., 85344.,
      88080., 90816., 82884., 85632., 88380., 91128., 83160., 85920., 88680.,
      91440., 83436., 86208., 88980., 91752., 83712., 86496., 89280., 92064.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60738., 61404., 45090., 66066., 66732.,
                                         48978., 39756., 40152., 29400.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13785., 13956., 14127., 15153., 15324.,
                                         15495., 16521., 16692., 16863.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119028., 121476., 120324., 122808., 88317., 90180.,
      129396., 132132., 130692., 133464., 95877., 97956.,
      77688.,  79512.,  78456.,  80304.,  57414., 58800.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26508., 27570., 26832., 27912., 27156., 28254., 29100., 30306., 29424.,
      30648., 29748., 30990., 31692., 33042., 32016., 33384., 32340., 33726.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      235608., 238056., 240504., 242952., 238164., 240648., 243132., 245616.,
      174771., 176634., 178497., 180360., 256056., 258792., 261528., 264264.,
      258612., 261384., 264156., 266928., 189675., 191754., 193833., 195912.,
      153552., 155376., 157200., 159024., 155064., 156912., 158760., 160608.,
      113442., 114828., 116214., 117600.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      51954., 53016., 54078., 55140., 52584., 53664., 54744., 55824., 53214.,
      54312., 55410., 56508., 56994., 58200., 59406., 60612., 57624., 58848.,
      60072., 61296., 58254., 59496., 60738., 61980., 62034., 63384., 64734.,
      66084., 62664., 64032., 65400., 66768., 63294., 64680., 66066., 67452.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120810., 121476., 122142., 122808., 89694., 90180.,
      131466., 132132., 132798., 133464., 97470., 97956.,
      79116.,  79512.,  79908.,  80304.,  58512., 58800.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27399., 27570., 27741., 27912., 28083., 28254., 30135., 30306., 30477.,
      30648., 30819., 30990., 32871., 33042., 33213., 33384., 33555., 33726.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236760., 241620., 238056., 242952., 239352., 244284., 240648., 245616.,
      175689., 179388., 176634., 180360., 257496., 262932., 258792., 264264.,
      260088., 265596., 261384., 266928., 190809., 194940., 191754., 195912.,
      154608., 158232., 155376., 159024., 156144., 159816., 156912., 160608.,
      114270., 117024., 114828., 117600.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52692., 54798., 53016., 55140., 53340., 55482., 53664., 55824., 53988.,
      56166., 54312., 56508., 57876., 60270., 58200., 60612., 58524., 60954.,
      58848., 61296., 59172., 61638., 59496., 61980., 63060., 65742., 63384.,
      66084., 63708., 66426., 64032., 66768., 64356., 67110., 64680., 67452.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      468660., 473520., 478380., 483240., 471216., 476112., 481008., 485904.,
      473772., 478704., 483636., 488568., 476328., 481296., 486264., 491232.,
      347679., 351378., 355077., 358776., 349542., 353268., 356994., 360720.,
      509556., 514992., 520428., 525864., 512112., 517584., 523056., 528528.,
      514668., 520176., 525684., 531192., 517224., 522768., 528312., 533856.,
      377487., 381618., 385749., 389880., 379350., 383508., 387666., 391824.,
      305592., 309216., 312840., 316464., 307104., 310752., 314400., 318048.,
      308616., 312288., 315960., 319632., 310128., 313824., 317520., 321216.,
      225786., 228540., 231294., 234048., 226884., 229656., 232428., 235200.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      103278., 105384., 107490., 109596., 103908., 106032., 108156., 110280.,
      104538., 106680., 108822., 110964., 105168., 107328., 109488., 111648.,
      105798., 107976., 110154., 112332., 106428., 108624., 110820., 113016.,
      113358., 115752., 118146., 120540., 113988., 116400., 118812., 121224.,
      114618., 117048., 119478., 121908., 115248., 117696., 120144., 122592.,
      115878., 118344., 120810., 123276., 116508., 118992., 121476., 123960.,
      123438., 126120., 128802., 131484., 124068., 126768., 129468., 132168.,
      124698., 127416., 130134., 132852., 125328., 128064., 130800., 133536.,
      125958., 128712., 131466., 134220., 126588., 129360., 132132., 134904.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240954., 241620., 242286., 242952., 243618., 244284., 244950., 245616.,
      178902., 179388., 179874., 180360., 262266., 262932., 263598., 264264.,
      264930., 265596., 266262., 266928., 194454., 194940., 195426., 195912.,
      157836., 158232., 158628., 159024., 159420., 159816., 160212., 160608.,
      116736., 117024., 117312., 117600.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54627., 54798., 54969., 55140., 55311., 55482., 55653., 55824., 55995.,
      56166., 56337., 56508., 60099., 60270., 60441., 60612., 60783., 60954.,
      61125., 61296., 61467., 61638., 61809., 61980., 65571., 65742., 65913.,
      66084., 66255., 66426., 66597., 66768., 66939., 67110., 67281., 67452.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      472224., 481908., 473520., 483240., 474816., 484572., 476112., 485904.,
      477408., 487236., 478704., 488568., 480000., 489900., 481296., 491232.,
      350433., 357804., 351378., 358776., 352323., 359748., 353268., 360720.,
      513696., 524532., 514992., 525864., 516288., 527196., 517584., 528528.,
      518880., 529860., 520176., 531192., 521472., 532524., 522768., 533856.,
      380673., 388908., 381618., 389880., 382563., 390852., 383508., 391824.,
      308448., 315672., 309216., 316464., 309984., 317256., 310752., 318048.,
      311520., 318840., 312288., 319632., 313056., 320424., 313824., 321216.,
      227982., 233472., 228540., 234048., 229098., 234624., 229656., 235200.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      105060., 109254., 105384., 109596., 105708., 109938., 106032., 110280.,
      106356., 110622., 106680., 110964., 107004., 111306., 107328., 111648.,
      107652., 111990., 107976., 112332., 108300., 112674., 108624., 113016.,
      115428., 120198., 115752., 120540., 116076., 120882., 116400., 121224.,
      116724., 121566., 117048., 121908., 117372., 122250., 117696., 122592.,
      118020., 122934., 118344., 123276., 118668., 123618., 118992., 123960.,
      125796., 131142., 126120., 131484., 126444., 131826., 126768., 132168.,
      127092., 132510., 127416., 132852., 127740., 133194., 128064., 133536.,
      128388., 133878., 128712., 134220., 129036., 134562., 129360., 134904.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      934764.,  944448.,  954132.,  963816.,  937320.,  947040.,  956760.,
      966480.,  939876.,  949632.,  959388.,  969144.,  942432.,  952224.,
      962016.,  971808.,  944988.,  954816.,  964644.,  974472.,  947544.,
      957408.,  967272.,  977136.,  950100.,  960000.,  969900.,  979800.,
      952656.,  962592.,  972528.,  982464.,  693495.,  700866.,  708237.,
      715608.,  695358.,  702756.,  710154.,  717552.,  697221.,  704646.,
      712071.,  719496.,  699084.,  706536.,  713988.,  721440.,  1016556.,
      1027392., 1038228., 1049064., 1019112., 1029984., 1040856., 1051728.,
      1021668., 1032576., 1043484., 1054392., 1024224., 1035168., 1046112.,
      1057056., 1026780., 1037760., 1048740., 1059720., 1029336., 1040352.,
      1051368., 1062384., 1031892., 1042944., 1053996., 1065048., 1034448.,
      1045536., 1056624., 1067712., 753111.,  761346.,  769581.,  777816.,
      754974.,  763236.,  771498.,  779760.,  756837.,  765126.,  773415.,
      781704.,  758700.,  767016.,  775332.,  783648.,  609672.,  616896.,
      624120.,  631344.,  611184.,  618432.,  625680.,  632928.,  612696.,
      619968.,  627240.,  634512.,  614208.,  621504.,  628800.,  636096.,
      615720.,  623040.,  630360.,  637680.,  617232.,  624576.,  631920.,
      639264.,  618744.,  626112.,  633480.,  640848.,  620256.,  627648.,
      635040.,  642432.,  450474.,  455964.,  461454.,  466944.,  451572.,
      457080.,  462588.,  468096.,  452670.,  458196.,  463722.,  469248.,
      453768.,  459312.,  464856.,  470400.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      205926., 210120., 214314., 218508., 206556., 210768., 214980., 219192.,
      207186., 211416., 215646., 219876., 207816., 212064., 216312., 220560.,
      208446., 212712., 216978., 221244., 209076., 213360., 217644., 221928.,
      209706., 214008., 218310., 222612., 210336., 214656., 218976., 223296.,
      210966., 215304., 219642., 223980., 211596., 215952., 220308., 224664.,
      212226., 216600., 220974., 225348., 212856., 217248., 221640., 226032.,
      226086., 230856., 235626., 240396., 226716., 231504., 236292., 241080.,
      227346., 232152., 236958., 241764., 227976., 232800., 237624., 242448.,
      228606., 233448., 238290., 243132., 229236., 234096., 238956., 243816.,
      229866., 234744., 239622., 244500., 230496., 235392., 240288., 245184.,
      231126., 236040., 240954., 245868., 231756., 236688., 241620., 246552.,
      232386., 237336., 242286., 247236., 233016., 237984., 242952., 247920.,
      246246., 251592., 256938., 262284., 246876., 252240., 257604., 262968.,
      247506., 252888., 258270., 263652., 248136., 253536., 258936., 264336.,
      248766., 254184., 259602., 265020., 249396., 254832., 260268., 265704.,
      250026., 255480., 260934., 266388., 250656., 256128., 261600., 267072.,
      251286., 256776., 262266., 267756., 251916., 257424., 262932., 268440.,
      252546., 258072., 263598., 269124., 253176., 258720., 264264., 269808.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35040., 51546., 33648., 37320., 54876.,
                                         35808., 25974., 38133., 24840.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12021., 12192., 12363., 12876., 13047.,
                                         13218., 13731., 13902., 14073.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68688., 70080., 101004., 103092., 65904., 67296.,
      73128., 74640., 107484., 109752., 70104., 71616.,
      50814., 51948., 74565.,  76266.,  48546., 49680.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23106., 24042., 23430., 24384., 23754., 24726., 24726., 25752., 25050.,
      26094., 25374., 26436., 26346., 27462., 26670., 27804., 26994., 28146.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      135984., 137376., 138768., 140160., 199920., 202008., 204096., 206184.,
      130416., 131808., 133200., 134592., 144744., 146256., 147768., 149280.,
      212700., 214968., 217236., 219504., 138696., 140208., 141720., 143232.,
      100494., 101628., 102762., 103896., 147429., 149130., 150831., 152532.,
      95958.,  97092.,  98226.,  99360.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45276., 46212., 47148., 48084., 45906., 46860., 47814., 48768., 46536.,
      47508., 48480., 49452., 48426., 49452., 50478., 51504., 49056., 50100.,
      51144., 52188., 49686., 50748., 51810., 52872., 51576., 52692., 53808.,
      54924., 52206., 53340., 54474., 55608., 52836., 53988., 55140., 56292.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69624., 70080., 102426., 103092., 66864., 67296.,
      74184., 74640., 109086., 109752., 71184., 71616.,
      51633., 51948., 75807.,  76266.,  49383., 49680.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23871., 24042., 24213., 24384., 24555., 24726., 25581., 25752., 25923.,
      26094., 26265., 26436., 27291., 27462., 27633., 27804., 27975., 28146.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136488., 139248., 137376., 140160., 200712., 204852., 202008., 206184.,
      130968., 133728., 131808., 134592., 145368., 148368., 146256., 149280.,
      213672., 218172., 214968., 219504., 139368., 142368., 140208., 143232.,
      101016., 103266., 101628., 103896., 148239., 151614., 149130., 152532.,
      96516.,  98766.,  97092.,  99360.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45888., 47742., 46212., 48084., 46536., 48426., 46860., 48768., 47184.,
      49110., 47508., 49452., 49128., 51162., 49452., 51504., 49776., 51846.,
      50100., 52188., 50424., 52530., 50748., 52872., 52368., 54582., 52692.,
      54924., 53016., 55266., 53340., 55608., 53664., 55950., 53988., 56292.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      270216., 272976., 275736., 278496., 271968., 274752., 277536., 280320.,
      397284., 401424., 405564., 409704., 399840., 404016., 408192., 412368.,
      259176., 261936., 264696., 267456., 260832., 263616., 266400., 269184.,
      287736., 290736., 293736., 296736., 289488., 292512., 295536., 298560.,
      422844., 427344., 431844., 436344., 425400., 429936., 434472., 439008.,
      275736., 278736., 281736., 284736., 277392., 280416., 283440., 286464.,
      199782., 202032., 204282., 206532., 200988., 203256., 205524., 207792.,
      293103., 296478., 299853., 303228., 294858., 298260., 301662., 305064.,
      190782., 193032., 195282., 197532., 191916., 194184., 196452., 198720.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89922.,  91776.,  93630.,  95484.,  90552.,  92424.,  94296.,  96168.,
      91182.,  93072.,  94962.,  96852.,  91812.,  93720.,  95628.,  97536.,
      92442.,  94368.,  96294.,  98220.,  93072.,  95016.,  96960.,  98904.,
      96222.,  98256.,  100290., 102324., 96852.,  98904.,  100956., 103008.,
      97482.,  99552.,  101622., 103692., 98112.,  100200., 102288., 104376.,
      98742.,  100848., 102954., 105060., 99372.,  101496., 103620., 105744.,
      102522., 104736., 106950., 109164., 103152., 105384., 107616., 109848.,
      103782., 106032., 108282., 110532., 104412., 106680., 108948., 111216.,
      105042., 107328., 109614., 111900., 105672., 107976., 110280., 112584.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138792., 139248., 139704., 140160., 204186., 204852., 205518., 206184.,
      133296., 133728., 134160., 134592., 147912., 148368., 148824., 149280.,
      217506., 218172., 218838., 219504., 141936., 142368., 142800., 143232.,
      102951., 103266., 103581., 103896., 151155., 151614., 152073., 152532.,
      98469.,  98766.,  99063.,  99360.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47571., 47742., 47913., 48084., 48255., 48426., 48597., 48768., 48939.,
      49110., 49281., 49452., 50991., 51162., 51333., 51504., 51675., 51846.,
      52017., 52188., 52359., 52530., 52701., 52872., 54411., 54582., 54753.,
      54924., 55095., 55266., 55437., 55608., 55779., 55950., 56121., 56292.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      272088., 277584., 272976., 278496., 273864., 279408., 274752., 280320.,
      400128., 408372., 401424., 409704., 402720., 411036., 404016., 412368.,
      261096., 266592., 261936., 267456., 262776., 268320., 263616., 269184.,
      289848., 295824., 290736., 296736., 291624., 297648., 292512., 298560.,
      426048., 435012., 427344., 436344., 428640., 437676., 429936., 439008.,
      277896., 283872., 278736., 284736., 279576., 285600., 280416., 286464.,
      201420., 205902., 202032., 206532., 202644., 207162., 203256., 207792.,
      295587., 302310., 296478., 303228., 297369., 304146., 298260., 305064.,
      192456., 196938., 193032., 197532., 193608., 198126., 194184., 198720.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91452.,  95142.,  91776.,  95484.,  92100.,  95826.,  92424.,  96168.,
      92748.,  96510.,  93072.,  96852.,  93396.,  97194.,  93720.,  97536.,
      94044.,  97878.,  94368.,  98220.,  94692.,  98562.,  95016.,  98904.,
      97932.,  101982., 98256.,  102324., 98580.,  102666., 98904.,  103008.,
      99228.,  103350., 99552.,  103692., 99876.,  104034., 100200., 104376.,
      100524., 104718., 100848., 105060., 101172., 105402., 101496., 105744.,
      104412., 108822., 104736., 109164., 105060., 109506., 105384., 109848.,
      105708., 110190., 106032., 110532., 106356., 110874., 106680., 111216.,
      107004., 111558., 107328., 111900., 107652., 112242., 107976., 112584.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      538680., 544176., 549672., 555168., 540432., 545952., 551472., 556992.,
      542184., 547728., 553272., 558816., 543936., 549504., 555072., 560640.,
      792012., 800256., 808500., 816744., 794568., 802848., 811128., 819408.,
      797124., 805440., 813756., 822072., 799680., 808032., 816384., 824736.,
      516696., 522192., 527688., 533184., 518352., 523872., 529392., 534912.,
      520008., 525552., 531096., 536640., 521664., 527232., 532800., 538368.,
      573720., 579696., 585672., 591648., 575472., 581472., 587472., 593472.,
      577224., 583248., 589272., 595296., 578976., 585024., 591072., 597120.,
      843132., 852096., 861060., 870024., 845688., 854688., 863688., 872688.,
      848244., 857280., 866316., 875352., 850800., 859872., 868944., 878016.,
      549816., 555792., 561768., 567744., 551472., 557472., 563472., 569472.,
      553128., 559152., 565176., 571200., 554784., 560832., 566880., 572928.,
      398358., 402840., 407322., 411804., 399564., 404064., 408564., 413064.,
      400770., 405288., 409806., 414324., 401976., 406512., 411048., 415584.,
      584451., 591174., 597897., 604620., 586206., 592956., 599706., 606456.,
      587961., 594738., 601515., 608292., 589716., 596520., 603324., 610128.,
      380430., 384912., 389394., 393876., 381564., 386064., 390564., 395064.,
      382698., 387216., 391734., 396252., 383832., 388368., 392904., 397440.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      179214., 182904., 186594., 190284., 179844., 183552., 187260., 190968.,
      180474., 184200., 187926., 191652., 181104., 184848., 188592., 192336.,
      181734., 185496., 189258., 193020., 182364., 186144., 189924., 193704.,
      182994., 186792., 190590., 194388., 183624., 187440., 191256., 195072.,
      184254., 188088., 191922., 195756., 184884., 188736., 192588., 196440.,
      185514., 189384., 193254., 197124., 186144., 190032., 193920., 197808.,
      191814., 195864., 199914., 203964., 192444., 196512., 200580., 204648.,
      193074., 197160., 201246., 205332., 193704., 197808., 201912., 206016.,
      194334., 198456., 202578., 206700., 194964., 199104., 203244., 207384.,
      195594., 199752., 203910., 208068., 196224., 200400., 204576., 208752.,
      196854., 201048., 205242., 209436., 197484., 201696., 205908., 210120.,
      198114., 202344., 206574., 210804., 198744., 202992., 207240., 211488.,
      204414., 208824., 213234., 217644., 205044., 209472., 213900., 218328.,
      205674., 210120., 214566., 219012., 206304., 210768., 215232., 219696.,
      206934., 211416., 215898., 220380., 207564., 212064., 216564., 221064.,
      208194., 212712., 217230., 221748., 208824., 213360., 217896., 222432.,
      209454., 214008., 218562., 223116., 210084., 214656., 219228., 223800.,
      210714., 215304., 219894., 224484., 211344., 215952., 220560., 225168.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61446., 62112., 40548., 65442., 66108.,
                                         43140., 45477., 45936., 29925.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14355., 14526., 14697., 15381., 15552.,
                                         15723., 16407., 16578., 16749.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120408., 122892., 121704., 124224., 79416., 81096.,
      128184., 130884., 129480., 132216., 84456., 86280.,
      88929.,  90954.,  89820.,  91872.,  58482., 59850.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27594., 28710., 27918., 29052., 28242., 29394., 29538., 30762., 29862.,
      31104., 30186., 31446., 31482., 32814., 31806., 33156., 32130., 33498.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      238332., 240816., 243300., 245784., 240888., 243408., 245928., 248448.,
      157152., 158832., 160512., 162192., 253668., 256368., 259068., 261768.,
      256224., 258960., 261696., 264432., 167088., 168912., 170736., 172560.,
      175833., 177858., 179883., 181908., 177588., 179640., 181692., 183744.,
      115596., 116964., 118332., 119700.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54072., 55188., 56304., 57420., 54702., 55836., 56970., 58104., 55332.,
      56484., 57636., 58788., 57852., 59076., 60300., 61524., 58482., 59724.,
      60966., 62208., 59112., 60372., 61632., 62892., 61632., 62964., 64296.,
      65628., 62262., 63612., 64962., 66312., 62892., 64260., 65628., 66996.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      122226., 122892., 123558., 124224., 80664., 81096.,
      130218., 130884., 131550., 132216., 85848., 86280.,
      90495.,  90954.,  91413.,  91872.,  59553., 59850.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28539., 28710., 28881., 29052., 29223., 29394., 30591., 30762., 30933.,
      31104., 31275., 31446., 32643., 32814., 32985., 33156., 33327., 33498.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      239520., 244452., 240816., 245784., 242112., 247116., 243408., 248448.,
      157992., 161328., 158832., 162192., 255072., 260436., 256368., 261768.,
      257664., 263100., 258960., 264432., 168072., 171696., 168912., 172560.,
      176967., 180990., 177858., 181908., 178749., 182826., 179640., 183744.,
      116388., 119106., 116964., 119700.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54864., 57078., 55188., 57420., 55512., 57762., 55836., 58104., 56160.,
      58446., 56484., 58788., 58752., 61182., 59076., 61524., 59400., 61866.,
      59724., 62208., 60048., 62550., 60372., 62892., 62640., 65286., 62964.,
      65628., 63288., 65970., 63612., 66312., 63936., 66654., 64260., 66996.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474108., 479040., 483972., 488904., 476664., 481632., 486600., 491568.,
      479220., 484224., 489228., 494232., 481776., 486816., 491856., 496896.,
      312648., 315984., 319320., 322656., 314304., 317664., 321024., 324384.,
      504780., 510144., 515508., 520872., 507336., 512736., 518136., 523536.,
      509892., 515328., 520764., 526200., 512448., 517920., 523392., 528864.,
      332520., 336144., 339768., 343392., 334176., 337824., 341472., 345120.,
      349911., 353934., 357957., 361980., 351666., 355716., 359766., 363816.,
      353421., 357498., 361575., 365652., 355176., 359280., 363384., 367488.,
      230058., 232776., 235494., 238212., 231192., 233928., 236664., 239400.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107514., 109728., 111942., 114156., 108144., 110376., 112608., 114840.,
      108774., 111024., 113274., 115524., 109404., 111672., 113940., 116208.,
      110034., 112320., 114606., 116892., 110664., 112968., 115272., 117576.,
      115074., 117504., 119934., 122364., 115704., 118152., 120600., 123048.,
      116334., 118800., 121266., 123732., 116964., 119448., 121932., 124416.,
      117594., 120096., 122598., 125100., 118224., 120744., 123264., 125784.,
      122634., 125280., 127926., 130572., 123264., 125928., 128592., 131256.,
      123894., 126576., 129258., 131940., 124524., 127224., 129924., 132624.,
      125154., 127872., 130590., 133308., 125784., 128520., 131256., 133992.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      243786., 244452., 245118., 245784., 246450., 247116., 247782., 248448.,
      160896., 161328., 161760., 162192., 259770., 260436., 261102., 261768.,
      262434., 263100., 263766., 264432., 171264., 171696., 172128., 172560.,
      180531., 180990., 181449., 181908., 182367., 182826., 183285., 183744.,
      118809., 119106., 119403., 119700.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      56907., 57078., 57249., 57420., 57591., 57762., 57933., 58104., 58275.,
      58446., 58617., 58788., 61011., 61182., 61353., 61524., 61695., 61866.,
      62037., 62208., 62379., 62550., 62721., 62892., 65115., 65286., 65457.,
      65628., 65799., 65970., 66141., 66312., 66483., 66654., 66825., 66996.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      477744., 487572., 479040., 488904., 480336., 490236., 481632., 491568.,
      482928., 492900., 484224., 494232., 485520., 495564., 486816., 496896.,
      315144., 321792., 315984., 322656., 316824., 323520., 317664., 324384.,
      508848., 519540., 510144., 520872., 511440., 522204., 512736., 523536.,
      514032., 524868., 515328., 526200., 516624., 527532., 517920., 528864.,
      335304., 342528., 336144., 343392., 336984., 344256., 337824., 345120.,
      353043., 361062., 353934., 361980., 354825., 362898., 355716., 363816.,
      356607., 364734., 357498., 365652., 358389., 366570., 359280., 367488.,
      232200., 237618., 232776., 238212., 233352., 238806., 233928., 239400.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109404., 113814., 109728., 114156., 110052., 114498., 110376., 114840.,
      110700., 115182., 111024., 115524., 111348., 115866., 111672., 116208.,
      111996., 116550., 112320., 116892., 112644., 117234., 112968., 117576.,
      117180., 122022., 117504., 122364., 117828., 122706., 118152., 123048.,
      118476., 123390., 118800., 123732., 119124., 124074., 119448., 124416.,
      119772., 124758., 120096., 125100., 120420., 125442., 120744., 125784.,
      124956., 130230., 125280., 130572., 125604., 130914., 125928., 131256.,
      126252., 131598., 126576., 131940., 126900., 132282., 127224., 132624.,
      127548., 132966., 127872., 133308., 128196., 133650., 128520., 133992.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      945660.,  955488.,  965316.,  975144.,  948216.,  958080.,  967944.,
      977808.,  950772.,  960672.,  970572.,  980472.,  953328.,  963264.,
      973200.,  983136.,  955884.,  965856.,  975828.,  985800.,  958440.,
      968448.,  978456.,  988464.,  960996.,  971040.,  981084.,  991128.,
      963552.,  973632.,  983712.,  993792.,  623640.,  630288.,  636936.,
      643584.,  625296.,  631968.,  638640.,  645312.,  626952.,  633648.,
      640344.,  647040.,  628608.,  635328.,  642048.,  648768.,  1007004.,
      1017696., 1028388., 1039080., 1009560., 1020288., 1031016., 1041744.,
      1012116., 1022880., 1033644., 1044408., 1014672., 1025472., 1036272.,
      1047072., 1017228., 1028064., 1038900., 1049736., 1019784., 1030656.,
      1041528., 1052400., 1022340., 1033248., 1044156., 1055064., 1024896.,
      1035840., 1046784., 1057728., 663384.,  670608.,  677832.,  685056.,
      665040.,  672288.,  679536.,  686784.,  666696.,  673968.,  681240.,
      688512.,  668352.,  675648.,  682944.,  690240.,  698067.,  706086.,
      714105.,  722124.,  699822.,  707868.,  715914.,  723960.,  701577.,
      709650.,  717723.,  725796.,  703332.,  711432.,  719532.,  727632.,
      705087.,  713214.,  721341.,  729468.,  706842.,  714996.,  723150.,
      731304.,  708597.,  716778.,  724959.,  733140.,  710352.,  718560.,
      726768.,  734976.,  458982.,  464400.,  469818.,  475236.,  460116.,
      465552.,  470988.,  476424.,  461250.,  466704.,  472158.,  477612.,
      462384.,  467856.,  473328.,  478800.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      214398., 218808., 223218., 227628., 215028., 219456., 223884., 228312.,
      215658., 220104., 224550., 228996., 216288., 220752., 225216., 229680.,
      216918., 221400., 225882., 230364., 217548., 222048., 226548., 231048.,
      218178., 222696., 227214., 231732., 218808., 223344., 227880., 232416.,
      219438., 223992., 228546., 233100., 220068., 224640., 229212., 233784.,
      220698., 225288., 229878., 234468., 221328., 225936., 230544., 235152.,
      229518., 234360., 239202., 244044., 230148., 235008., 239868., 244728.,
      230778., 235656., 240534., 245412., 231408., 236304., 241200., 246096.,
      232038., 236952., 241866., 246780., 232668., 237600., 242532., 247464.,
      233298., 238248., 243198., 248148., 233928., 238896., 243864., 248832.,
      234558., 239544., 244530., 249516., 235188., 240192., 245196., 250200.,
      235818., 240840., 245862., 250884., 236448., 241488., 246528., 251568.,
      244638., 249912., 255186., 260460., 245268., 250560., 255852., 261144.,
      245898., 251208., 256518., 261828., 246528., 251856., 257184., 262512.,
      247158., 252504., 257850., 263196., 247788., 253152., 258516., 263880.,
      248418., 253800., 259182., 264564., 249048., 254448., 259848., 265248.,
      249678., 255096., 260514., 265932., 250308., 255744., 261180., 266616.,
      250938., 256392., 261846., 267300., 251568., 257040., 262512., 267984.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {144920., 146096., 107856.,
                                         154328., 155504., 114768.,
                                         107202., 108012., 79614.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {42642., 43020., 43398., 45666., 46044.,
                                         46422., 48690., 49068., 49446.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      285424., 289840., 287728., 292192., 212364., 215712.,
      303856., 308656., 306160., 311008., 225900., 229536.,
      210804., 214404., 212388., 216024., 156501., 159228.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83043., 85284., 83772., 86040., 84501., 86796., 88875., 91332., 89604.,
      92088., 90333., 92844., 94707., 97380., 95436., 98136., 96165., 98892.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      566432., 570848., 575264., 579680., 570992., 575456., 579920., 584384.,
      421380., 424728., 428076., 431424., 602912., 607712., 612512., 617312.,
      607472., 612320., 617168., 622016., 448164., 451800., 455436., 459072.,
      418008., 421608., 425208., 428808., 421140., 424776., 428412., 432048.,
      310275., 313002., 315729., 318456.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      163845., 166086., 168327., 170568., 165276., 167544., 169812., 172080.,
      166707., 169002., 171297., 173592., 175293., 177750., 180207., 182664.,
      176724., 179208., 181692., 184176., 178155., 180666., 183177., 185688.,
      186741., 189414., 192087., 194760., 188172., 190872., 193572., 196272.,
      189603., 192330., 195057., 197784.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288664., 289840., 291016., 292192., 214848., 215712.,
      307480., 308656., 309832., 311008., 228672., 229536.,
      213594., 214404., 215214., 216024., 158634., 159228.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84906., 85284., 85662., 86040., 86418., 86796., 90954., 91332., 91710.,
      92088., 92466., 92844., 97002., 97380., 97758., 98136., 98514., 98892.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      568544., 577328., 570848., 579680., 573152., 582032., 575456., 584384.,
      423036., 429696., 424728., 431424., 605408., 614960., 607712., 617312.,
      610016., 619664., 612320., 622016., 450108., 457344., 451800., 459072.,
      420024., 427188., 421608., 428808., 423192., 430428., 424776., 432048.,
      311841., 317268., 313002., 318456.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      165357., 169812., 166086., 170568., 166815., 171324., 167544., 172080.,
      168273., 172836., 169002., 173592., 177021., 181908., 177750., 182664.,
      178479., 183420., 179208., 184176., 179937., 184932., 180666., 185688.,
      188685., 194004., 189414., 194760., 190143., 195516., 190872., 196272.,
      191601., 197028., 192330., 197784.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1128304., 1137088., 1145872., 1154656., 1132864., 1141696., 1150528.,
      1159360., 1137424., 1146304., 1155184., 1164064., 1141984., 1150912.,
      1159840., 1168768., 839412.,  846072.,  852732.,  859392.,  842760.,
      849456.,  856152.,  862848.,  1201264., 1210816., 1220368., 1229920.,
      1205824., 1215424., 1225024., 1234624., 1210384., 1220032., 1229680.,
      1239328., 1214944., 1224640., 1234336., 1244032., 892980.,  900216.,
      907452.,  914688.,  896328.,  903600.,  910872.,  918144.,  832884.,
      840048.,  847212.,  854376.,  836016.,  843216.,  850416.,  857616.,
      839148.,  846384.,  853620.,  860856.,  842280.,  849552.,  856824.,
      864096.,  618255.,  623682.,  629109.,  634536.,  620550.,  626004.,
      631458.,  636912.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      326259., 330714., 335169., 339624., 327690., 332172., 336654., 341136.,
      329121., 333630., 338139., 342648., 330552., 335088., 339624., 344160.,
      331983., 336546., 341109., 345672., 333414., 338004., 342594., 347184.,
      349155., 354042., 358929., 363816., 350586., 355500., 360414., 365328.,
      352017., 356958., 361899., 366840., 353448., 358416., 363384., 368352.,
      354879., 359874., 364869., 369864., 356310., 361332., 366354., 371376.,
      372051., 377370., 382689., 388008., 373482., 378828., 384174., 389520.,
      374913., 380286., 385659., 391032., 376344., 381744., 387144., 392544.,
      377775., 383202., 388629., 394056., 379206., 384660., 390114., 395568.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      576152., 577328., 578504., 579680., 580856., 582032., 583208., 584384.,
      428832., 429696., 430560., 431424., 613784., 614960., 616136., 617312.,
      618488., 619664., 620840., 622016., 456480., 457344., 458208., 459072.,
      426378., 427188., 427998., 428808., 429618., 430428., 431238., 432048.,
      316674., 317268., 317862., 318456.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      169434., 169812., 170190., 170568., 170946., 171324., 171702., 172080.,
      172458., 172836., 173214., 173592., 181530., 181908., 182286., 182664.,
      183042., 183420., 183798., 184176., 184554., 184932., 185310., 185688.,
      193626., 194004., 194382., 194760., 195138., 195516., 195894., 196272.,
      196650., 197028., 197406., 197784.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1134784., 1152304., 1137088., 1154656., 1139392., 1157008., 1141696.,
      1159360., 1144000., 1161712., 1146304., 1164064., 1148608., 1166416.,
      1150912., 1168768., 844380.,  857664.,  846072.,  859392.,  847764.,
      861120.,  849456.,  862848.,  1208512., 1227568., 1210816., 1229920.,
      1213120., 1232272., 1215424., 1234624., 1217728., 1236976., 1220032.,
      1239328., 1222336., 1241680., 1224640., 1244032., 898524.,  912960.,
      900216.,  914688.,  901908.,  916416.,  903600.,  918144.,  838464.,
      852756.,  840048.,  854376.,  841632.,  855996.,  843216.,  857616.,
      844800.,  859236.,  846384.,  860856.,  847968.,  862476.,  849552.,
      864096.,  622521.,  633348.,  623682.,  634536.,  624843.,  635724.,
      626004.,  636912.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      329985., 338868., 330714., 339624., 331443., 340380., 332172., 341136.,
      332901., 341892., 333630., 342648., 334359., 343404., 335088., 344160.,
      335817., 344916., 336546., 345672., 337275., 346428., 338004., 347184.,
      353313., 363060., 354042., 363816., 354771., 364572., 355500., 365328.,
      356229., 366084., 356958., 366840., 357687., 367596., 358416., 368352.,
      359145., 369108., 359874., 369864., 360603., 370620., 361332., 371376.,
      376641., 387252., 377370., 388008., 378099., 388764., 378828., 389520.,
      379557., 390276., 380286., 391032., 381015., 391788., 381744., 392544.,
      382473., 393300., 383202., 394056., 383931., 394812., 384660., 395568.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2252048., 2269568., 2287088., 2304608., 2256608., 2274176., 2291744.,
      2309312., 2261168., 2278784., 2296400., 2314016., 2265728., 2283392.,
      2301056., 2318720., 2270288., 2288000., 2305712., 2323424., 2274848.,
      2292608., 2310368., 2328128., 2279408., 2297216., 2315024., 2332832.,
      2283968., 2301824., 2319680., 2337536., 1675476., 1688760., 1702044.,
      1715328., 1678824., 1692144., 1705464., 1718784., 1682172., 1695528.,
      1708884., 1722240., 1685520., 1698912., 1712304., 1725696., 2397968.,
      2417024., 2436080., 2455136., 2402528., 2421632., 2440736., 2459840.,
      2407088., 2426240., 2445392., 2464544., 2411648., 2430848., 2450048.,
      2469248., 2416208., 2435456., 2454704., 2473952., 2420768., 2440064.,
      2459360., 2478656., 2425328., 2444672., 2464016., 2483360., 2429888.,
      2449280., 2468672., 2488064., 1782612., 1797048., 1811484., 1825920.,
      1785960., 1800432., 1814904., 1829376., 1789308., 1803816., 1818324.,
      1832832., 1792656., 1807200., 1821744., 1836288., 1662636., 1676928.,
      1691220., 1705512., 1665768., 1680096., 1694424., 1708752., 1668900.,
      1683264., 1697628., 1711992., 1672032., 1686432., 1700832., 1715232.,
      1675164., 1689600., 1704036., 1718472., 1678296., 1692768., 1707240.,
      1721712., 1681428., 1695936., 1710444., 1724952., 1684560., 1699104.,
      1713648., 1728192., 1234215., 1245042., 1255869., 1266696., 1236510.,
      1247364., 1258218., 1269072., 1238805., 1249686., 1260567., 1271448.,
      1241100., 1252008., 1262916., 1273824.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      651087., 659970., 668853., 677736., 652518., 661428., 670338., 679248.,
      653949., 662886., 671823., 680760., 655380., 664344., 673308., 682272.,
      656811., 665802., 674793., 683784., 658242., 667260., 676278., 685296.,
      659673., 668718., 677763., 686808., 661104., 670176., 679248., 688320.,
      662535., 671634., 680733., 689832., 663966., 673092., 682218., 691344.,
      665397., 674550., 683703., 692856., 666828., 676008., 685188., 694368.,
      696879., 706626., 716373., 726120., 698310., 708084., 717858., 727632.,
      699741., 709542., 719343., 729144., 701172., 711000., 720828., 730656.,
      702603., 712458., 722313., 732168., 704034., 713916., 723798., 733680.,
      705465., 715374., 725283., 735192., 706896., 716832., 726768., 736704.,
      708327., 718290., 728253., 738216., 709758., 719748., 729738., 739728.,
      711189., 721206., 731223., 741240., 712620., 722664., 732708., 742752.,
      742671., 753282., 763893., 774504., 744102., 754740., 765378., 776016.,
      745533., 756198., 766863., 777528., 746964., 757656., 768348., 779040.,
      748395., 759114., 769833., 780552., 749826., 760572., 771318., 782064.,
      751257., 762030., 772803., 783576., 752688., 763488., 774288., 785088.,
      754119., 764946., 775773., 786600., 755550., 766404., 777258., 788112.,
      756981., 767862., 778743., 789624., 758412., 769320., 780228., 791136.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}